
bin/main.elf:     file format elf32-littlearm

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00001268  00000000  00000000  00010000  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .text.arm_Init 00000138  00001268  00001268  00011268  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .text._start  00000048  000013a0  000013a0  000113a0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  3 .text.nmi_ISR 00000020  000013e8  000013e8  000113e8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  4 .text.hardFault_ISR 00000050  00001408  00001408  00011408  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  5 .text.memManage_ISR 00000020  00001458  00001458  00011458  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  6 .text.busFault_ISR 00000020  00001478  00001478  00011478  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  7 .text.usageFault_ISR 00000020  00001498  00001498  00011498  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  8 .text.svc_ISR 00000020  000014b8  000014b8  000114b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  9 .text.debugMon_ISR 00000020  000014d8  000014d8  000114d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 10 .text.pendSV_ISR 00000020  000014f8  000014f8  000114f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 11 .text.wdt_ISR 00000020  00001518  00001518  00011518  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 12 .text.timer0_ISR 00000020  00001538  00001538  00011538  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 13 .text.timer1_ISR 00000020  00001558  00001558  00011558  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 14 .text.timer2_ISR 00000020  00001578  00001578  00011578  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 15 .text.timer3_ISR 00000020  00001598  00001598  00011598  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 16 .text.uart2_ISR 00000020  000015b8  000015b8  000115b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 17 .text.pwm_ISR 00000020  000015d8  000015d8  000115d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 18 .text.i2c0_ISR 00000020  000015f8  000015f8  000115f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 19 .text.i2c1_ISR 00000020  00001618  00001618  00011618  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 20 .text.i2c2_ISR 00000020  00001638  00001638  00011638  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 21 .text.spi_ISR 00000020  00001658  00001658  00011658  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 22 .text.ssp0_ISR 00000020  00001678  00001678  00011678  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 23 .text.ssp1_ISR 00000020  00001698  00001698  00011698  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 24 .text.pll0_ISR 00000020  000016b8  000016b8  000116b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 25 .text.rtc_ISR 00000020  000016d8  000016d8  000116d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 26 .text.eint0_ISR 00000020  000016f8  000016f8  000116f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 27 .text.eint1_ISR 00000020  00001718  00001718  00011718  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 28 .text.eint2_ISR 00000020  00001738  00001738  00011738  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 29 .text.eint3_ISR 00000020  00001758  00001758  00011758  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 30 .text.adc_ISR 00000020  00001778  00001778  00011778  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 31 .text.bod_ISR 00000020  00001798  00001798  00011798  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 32 .text.usbHost_ISR 00000020  000017b8  000017b8  000117b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 33 .text.can_ISR 00000020  000017d8  000017d8  000117d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 34 .text.dma_ISR 00000020  000017f8  000017f8  000117f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 35 .text.i2s_ISR 00000020  00001818  00001818  00011818  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 36 .text.enet_ISR 00000020  00001838  00001838  00011838  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 37 .text.rit_ISR 00000020  00001858  00001858  00011858  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 38 .text.mcpwm_ISR 00000020  00001878  00001878  00011878  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 39 .text.qei_ISR 00000020  00001898  00001898  00011898  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 40 .text.pll1_ISR 00000020  000018b8  000018b8  000118b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 41 .text.usbAct_ISR 00000020  000018d8  000018d8  000118d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 42 .text.canAct_ISR 00000020  000018f8  000018f8  000118f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 43 .text.uart4_ISR 00000020  00001918  00001918  00011918  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 44 .text.ssp2_ISR 00000020  00001938  00001938  00011938  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 45 .text.lcd_ISR 00000020  00001958  00001958  00011958  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 46 .text.gpio_ISR 00000020  00001978  00001978  00011978  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 47 .text.pwm0_ISR 00000020  00001998  00001998  00011998  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 48 .text.eeprom_ISR 00000020  000019b8  000019b8  000119b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 49 .text.nvic_setPendingIRQ 0000001a  000019d8  000019d8  000119d8  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 50 .text.nvic_enableIRQ 00000004  000019f2  000019f2  000119f2  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 51 .text.nvic_clearPendingIRQ 00000018  000019f8  000019f8  000119f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 52 .text.nvic_setPriority 00000044  00001a10  00001a10  00011a10  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 53 .text.nvic_SetIntHandler 0000000c  00001a54  00001a54  00011a54  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 54 .text.systime_Init 0000005c  00001a60  00001a60  00011a60  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 55 .text.systime_SetIntHandler 00000014  00001abc  00001abc  00011abc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 56 .text.sysTick_ISR 00000064  00001ad0  00001ad0  00011ad0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 57 .text.delay   00000006  00001b34  00001b34  00011b34  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 58 .text.uart0_SetBaudrate 000000ec  00001b40  00001b40  00011b40  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 59 .text.uart0_Init 000000b0  00001c2c  00001c2c  00011c2c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 60 .text.uart0_GetChar 00000044  00001cdc  00001cdc  00011cdc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 61 .text.uart0_PutChar 00000068  00001d20  00001d20  00011d20  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 62 .text.uart0_BasicPutChar 0000001c  00001d88  00001d88  00011d88  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 63 .text.uart0_ISR 000000b4  00001da4  00001da4  00011da4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 64 .text.uart1_SetBaudrate 000000ec  00001e58  00001e58  00011e58  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 65 .text.uart1_Init 000000c0  00001f44  00001f44  00011f44  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 66 .text.uart1_GetChar 00000044  00002004  00002004  00012004  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 67 .text.uart1_ClearBufferRx 0000003c  00002048  00002048  00012048  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 68 .text.uart1_PutChar 00000068  00002084  00002084  00012084  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 69 .text.uart1_SpaceTx 00000028  000020ec  000020ec  000120ec  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 70 .text.uart1_EmptyTx 00000018  00002114  00002114  00012114  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 71 .text.uart1_WriteTx 0000002c  0000212c  0000212c  0001212c  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 72 .text.uart1_ISR 000000b4  00002158  00002158  00012158  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 73 .text.uart3_SetBaudrate 000000ec  00002210  00002210  00012210  2**3
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 74 .text.uart3_Init 000000a8  000022fc  000022fc  000122fc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 75 .text.uart3_GetChar 00000044  000023a4  000023a4  000123a4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 76 .text.uart3_ClearBufferRx 0000003c  000023e8  000023e8  000123e8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 77 .text.uart3_BufferQtdRx 0000000c  00002424  00002424  00012424  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 78 .text.uart3_PutChar 00000068  00002430  00002430  00012430  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 79 .text.uart3_SpaceTx 00000028  00002498  00002498  00012498  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 80 .text.uart3_EmptyTx 00000018  000024c0  000024c0  000124c0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 81 .text.uart3_WriteTx 0000002c  000024d8  000024d8  000124d8  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 82 .text.uart3_ISR 000000b4  00002504  00002504  00012504  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 83 .text.showVicError 00000078  000025b8  000025b8  000125b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 84 .text.startup.main 000000b8  00002630  00002630  00012630  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 85 .text.breakFloat 00000036  000026e8  000026e8  000126e8  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 86 .text.stringFloat 00000020  00002720  00002720  00012720  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 87 .text.temp_InitStatistic 00000010  00002740  00002740  00012740  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 88 .text.temp_SetType 00000014  00002750  00002750  00012750  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 89 .text.onKeyDown 00000034  00002764  00002764  00012764  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 90 .text.onKeyPress 00000018  00002798  00002798  00012798  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 91 .text.onKeyUp 00000018  000027b0  000027b0  000127b0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 92 .text.relay_Init 00000028  000027c8  000027c8  000127c8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 93 .text.relay_Set 00000030  000027f0  000027f0  000127f0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 94 .text.relay_Tick 00000068  00002820  00002820  00012820  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 95 .text.app_Init 00000070  00002888  00002888  00012888  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 96 .text.app_Tick 000000a8  000028f8  000028f8  000128f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 97 .text.app_Process 0000012c  000029a0  000029a0  000129a0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 98 .text.prompt_ClearTicks 00000010  00002acc  00002acc  00012acc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
 99 .text.prompt_STS 00000174  00002adc  00002adc  00012adc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
100 .text.prompt_Dump 0000008a  00002c50  00002c50  00012c50  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
101 .text.prompt_Beep 0000001a  00002cda  00002cda  00012cda  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
102 .text.prompt_SetTempType 0000008c  00002cf4  00002cf4  00012cf4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
103 .text.prompt_Relay 00000068  00002d80  00002d80  00012d80  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
104 .text.prompt_ResetSt 00000024  00002de8  00002de8  00012de8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
105 .text.prompt_Process 00000088  00002e0c  00002e0c  00012e0c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
106 .text.master_PutString 0000002c  00002e94  00002e94  00012e94  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
107 .text.slave_PutString 0000002c  00002ec0  00002ec0  00012ec0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
108 .text.slave_ReadRegisters 000000e4  00002eec  00002eec  00012eec  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
109 .text.slave_SetValue 00000044  00002fd0  00002fd0  00012fd0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
110 .text.slave_WriteRegister 00000020  00003014  00003014  00013014  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
111 .text.slave_WriteRegisters 00000048  00003034  00003034  00013034  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
112 .text.modbus_Init 00000094  0000307c  0000307c  0001307c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
113 .text.modbus_SendCommand 00000050  00003110  00003110  00013110  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
114 .text.modbus_Tick 0000000e  00003160  00003160  00013160  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
115 .text.modbus_Process 00000180  00003170  00003170  00013170  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
116 .text.crc16_Right 00000046  000032f0  000032f0  000132f0  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
117 .text.crc16_MODBUS 0000000c  00003336  00003336  00013336  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
118 .text.ValidatePacket 00000040  00003344  00003344  00013344  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
119 .text.modbus_MasterInit 00000034  00003384  00003384  00013384  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
120 .text.modbus_MasterTimeout 0000000c  000033b8  000033b8  000133b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
121 .text.modbus_MasterReadStatus 0000000c  000033c4  000033c4  000133c4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
122 .text.modbus_MasterReadException 0000000c  000033d0  000033d0  000133d0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
123 .text.modbus_MasterReadRegisters 0000007c  000033dc  000033dc  000133dc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
124 .text.modbus_MasterWriteRegister 00000084  00003458  00003458  00013458  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
125 .text.modbus_MasterProcess 0000019c  000034dc  000034dc  000134dc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
126 .text.modbus_MasterTick 0000002c  00003678  00003678  00013678  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
127 .text.modbus_SendPacketException 00000034  000036a4  000036a4  000136a4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
128 .text.modbus_SlaveInit 00000028  000036d8  000036d8  000136d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
129 .text.modbus_SlaveAppendFunctions 00000014  00003700  00003700  00013700  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
130 .text.modbus_SlaveProcess 00000168  00003714  00003714  00013714  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
131 .text.modbus_SlaveTick 00000014  0000387c  0000387c  0001387c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
132 .text.print_putchar 00000074  00003890  00003890  00013890  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
133 .text.print_fill 0000001a  00003904  00003904  00013904  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
134 .text.print_int 00000058  0000391e  0000391e  0001391e  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
135 .text.print_long 0000004e  00003976  00003976  00013976  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
136 .text.print_float 000000b4  000039c4  000039c4  000139c4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
137 .text.rprintf_RegisterDev 00000030  00003a78  00003a78  00013a78  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
138 .text.lputchar_RegisterDev 0000000c  00003aa8  00003aa8  00013aa8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
139 .text.ldebug_RegisterDev 0000000c  00003ab4  00003ab4  00013ab4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
140 .text.lgetchar_RegisterDev 0000000c  00003ac0  00003ac0  00013ac0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
141 .text.doprint 00000378  00003acc  00003acc  00013acc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
142 .text.lgetchar 0000000c  00003e44  00003e44  00013e44  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
143 .text.rprintf 0000002a  00003e50  00003e50  00013e50  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
144 .text.sformat 0000002a  00003e7a  00003e7a  00013e7a  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
145 .text.buffer_Init 0000000c  00003ea4  00003ea4  00013ea4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
146 .text.buffer_GetFromFront 00000044  00003eb0  00003eb0  00013eb0  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
147 .text.buffer_AddToEnd 0000003a  00003ef4  00003ef4  00013ef4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
148 .text.buffer_IsEmpty 0000000c  00003f2e  00003f2e  00013f2e  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
149 .text.buffer_Clear 00000006  00003f3a  00003f3a  00013f3a  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
150 .text.put_dump16 00000094  00003f40  00003f40  00013f40  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
151 .text.xatoi   000000a8  00003fd4  00003fd4  00013fd4  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
152 .text.ledError_Init 00000018  0000407c  0000407c  0001407c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
153 .text.ledError_Tick 00000090  00004094  00004094  00014094  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
154 .text.gKey_Init 00000024  00004124  00004124  00014124  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
155 .text.gKey_Tick 00000014  00004148  00004148  00014148  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
156 .text.gKey_Process 000000a8  0000415c  0000415c  0001415c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
157 .text.beep_SetType 00000088  00004204  00004204  00014204  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
158 .text.beep_Init 0000002c  0000428c  0000428c  0001428c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
159 .text.beep_Play 00000024  000042b8  000042b8  000142b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
160 .text.beep_Tick 0000008c  000042dc  000042dc  000142dc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
161 .text.cli_GetLine 000000f4  00004368  00004368  00014368  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
162 .text.cli_Help 00000098  0000445c  0000445c  0001445c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
163 .text.cli_ArgsParse 000000f0  000044f4  000044f4  000144f4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
164 .text.cli_ArgsDispatch 000000a0  000045e4  000045e4  000145e4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
165 .text.lcd_command 0000001a  00004684  00004684  00014684  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
166 .text.lcd_PutChar 0000001a  0000469e  0000469e  0001469e  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
167 .text.lcd_Clear 00000018  000046b8  000046b8  000146b8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
168 .text.lcd_SetCursor 0000002c  000046d0  000046d0  000146d0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
169 .text.lcd_Display 00000018  000046fc  000046fc  000146fc  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
170 .text.lcd_Init 000000b0  00004714  00004714  00014714  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
171 .text.lcd_printfInit 00000020  000047c4  000047c4  000147c4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
172 .text.lcd_printf 0000005c  000047e4  000047e4  000147e4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
173 .text.lcd_config_ports 00000028  00004840  00004840  00014840  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
174 .text.lcd_read 00000090  00004868  00004868  00014868  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
175 .text.lcd_write 000000c8  000048f8  000048f8  000148f8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
176 .text.__get_current_locale 00000018  000049c0  000049c0  000149c0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
177 .text.__locale_ctype_ptr 00000014  000049d8  000049d8  000149d8  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
178 .text.__ascii_mbtowc 0000002c  000049ec  000049ec  000149ec  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
179 .text.memset  0000009c  00004a18  00004a18  00014a18  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
180 .text.strlen  0000005c  00004ab4  00004ab4  00014ab4  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
181 .text.__ascii_wctomb 0000001c  00004b10  00004b10  00014b10  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
182 .rodata       00000ac5  00004b2c  00004b2c  00014b2c  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
183 .data         000005ac  10000000  000055f4  00020000  2**3
                  CONTENTS, ALLOC, LOAD, DATA
184 .bss          00000049  100005ac  00005ba0  000205ac  2**2
                  ALLOC
185 .bss.vicerr_Functions 00000004  100005f8  00005bec  000205ac  2**2
                  ALLOC
186 .bss.countTicksLed 00000004  100005fc  00005bf0  000205ac  2**2
                  ALLOC
187 .bss.countTicks_ms 00000004  10000600  00005bf4  000205ac  2**2
                  ALLOC
188 .bss.callfuncTime 00000004  10000604  00005bf8  000205ac  2**2
                  ALLOC
189 .bss.systime_IntFunctions 00000004  10000608  00005bfc  000205ac  2**2
                  ALLOC
190 .bss.u0_data_tx 00000096  1000060c  00005c00  000205ac  2**0
                  ALLOC
191 .bss.u0_tx_running 00000001  100006a2  00005c96  000205ac  2**0
                  ALLOC
192 .bss.u0_overflow_rx 00000002  100006a4  00005c98  000205ac  2**1
                  ALLOC
193 .bss.u0_buf_rx 0000000c  100006a8  00005c9c  000205ac  2**2
                  ALLOC
194 .bss.u0_buf_tx 0000000c  100006b4  00005ca8  000205ac  2**2
                  ALLOC
195 .bss.u0_data_rx 00000096  100006c0  00005cb4  000205ac  2**0
                  ALLOC
196 .bss.u1_tx_running 00000001  10000756  00005d4a  000205ac  2**0
                  ALLOC
197 .bss.u1_overflow_rx 00000002  10000758  00005d4c  000205ac  2**1
                  ALLOC
198 .bss.u1_data_rx 00000096  1000075a  00005d4e  000205ac  2**0
                  ALLOC
199 .bss.u1_buf_rx 0000000c  100007f0  00005de4  000205ac  2**2
                  ALLOC
200 .bss.u1_data_tx 00000096  100007fc  00005df0  000205ac  2**0
                  ALLOC
201 .bss.u1_buf_tx 0000000c  10000894  00005e88  000205ac  2**2
                  ALLOC
202 .bss.u3_buf_tx 0000000c  100008a0  00005e94  000205ac  2**2
                  ALLOC
203 .bss.u3_tx_running 00000001  100008ac  00005ea0  000205ac  2**0
                  ALLOC
204 .bss.u3_data_rx 00000096  100008ad  00005ea1  000205ac  2**0
                  ALLOC
205 .bss.u3_data_tx 00000096  10000943  00005f37  000205ac  2**0
                  ALLOC
206 .bss.u3_overflow_rx 00000002  100009da  00005fce  000205ac  2**1
                  ALLOC
207 .bss.u3_buf_rx 0000000c  100009dc  00005fd0  000205ac  2**2
                  ALLOC
208 .bss.x.4991   00000004  100009e8  00005fdc  000205ac  2**2
                  ALLOC
209 .bss.idx.5874 00000004  100009ec  00005fe0  000205ac  2**2
                  ALLOC
210 .bss.timeReadKey.5872 00000004  100009f0  00005fe4  000205ac  2**2
                  ALLOC
211 .bss.bufKey.5873 0000000c  100009f4  00005fe8  000205ac  2**2
                  ALLOC
212 .bss.ticks_d.5879 00000004  10000a00  00005ff4  000205ac  2**2
                  ALLOC
213 .bss.argc_prompt 00000004  10000a04  00005ff8  000205ac  2**2
                  ALLOC
214 .bss.result_prompt 00000004  10000a08  00005ffc  000205ac  2**2
                  ALLOC
215 .bss.argv_prompt 00000028  10000a0c  00006000  000205ac  2**2
                  ALLOC
216 .bss.buffer_prompt 00000028  10000a34  00006028  000205ac  2**0
                  ALLOC
217 .bss.cmd      00000001  10000a5c  00006050  000205ac  2**0
                  ALLOC
218 .bss.waitResponse 00000004  10000a60  00006054  000205ac  2**2
                  ALLOC
219 .bss.triggerAction 00000004  10000a64  00006058  000205ac  2**2
                  ALLOC
220 .bss.regs     000000f0  10000a68  0000605c  000205ac  2**1
                  ALLOC
221 .bss.modbus   00000268  10000b58  0000614c  000205ac  2**2
                  ALLOC
222 .bss.len.4327 00000004  10000dc0  000063b4  000205ac  2**2
                  ALLOC
223 .bss.dev1_putc 00000004  10000dc4  000063b8  000205ac  2**2
                  ALLOC
224 .bss.stdio_putc 00000004  10000dc8  000063bc  000205ac  2**2
                  ALLOC
225 .bss.putcharfunc.4737 00000004  10000dcc  000063c0  000205ac  2**2
                  ALLOC
226 .bss.dev3_putc 00000004  10000dd0  000063c4  000205ac  2**2
                  ALLOC
227 .bss.dev2_putc 00000004  10000dd4  000063c8  000205ac  2**2
                  ALLOC
228 .bss.stdio_getc 00000004  10000dd8  000063cc  000205ac  2**2
                  ALLOC
229 .bss.dev4_putc 00000004  10000ddc  000063d0  000205ac  2**2
                  ALLOC
230 .bss.debug_putc 00000004  10000de0  000063d4  000205ac  2**2
                  ALLOC
231 .bss.err_putc 00000004  10000de4  000063d8  000205ac  2**2
                  ALLOC
232 .bss.count1.4249 00000004  10000de8  000063dc  000205ac  2**2
                  ALLOC
233 .bss.error    00000004  10000dec  000063e0  000205ac  2**2
                  ALLOC
234 .bss.ledBlink 00000004  10000df0  000063e4  000205ac  2**2
                  ALLOC
235 .bss.ff.4251  00000004  10000df4  000063e8  000205ac  2**2
                  ALLOC
236 .bss.count2.4250 00000004  10000df8  000063ec  000205ac  2**2
                  ALLOC
237 .bss.nTimes.4252 00000004  10000dfc  000063f0  000205ac  2**2
                  ALLOC
238 .bss.repeat.4250 00000004  10000e00  000063f4  000205ac  2**2
                  ALLOC
239 .bss.estado.4249 00000001  10000e04  000063f8  000205ac  2**0
                  ALLOC
240 .bss.onKeyUp  00000004  10000e08  000063fc  000205ac  2**2
                  ALLOC
241 .bss.timeRepeat 00000004  10000e0c  00006400  000205ac  2**2
                  ALLOC
242 .bss.keynow.4248 00000001  10000e10  00006404  000205ac  2**0
                  ALLOC
243 .bss.onKeyDown 00000004  10000e14  00006408  000205ac  2**2
                  ALLOC
244 .bss.onKeyPress 00000004  10000e18  0000640c  000205ac  2**2
                  ALLOC
245 .bss.beep     00000030  10000e1c  00006410  000205ac  2**2
                  ALLOC
246 .bss.cmd_list_active 00000004  10000e4c  00006440  000205ac  2**2
                  ALLOC
247 .bss.p        00000004  10000e50  00006444  000205ac  2**2
                  ALLOC
248 .bss.c        00000001  10000e54  00006448  000205ac  2**0
                  ALLOC
249 .bss.devicePrintf 00000004  10000e58  0000644c  000205ac  2**2
                  ALLOC
250 .comment      0000006e  00000000  00000000  000205ac  2**0
                  CONTENTS, READONLY
251 .ARM.attributes 00000031  00000000  00000000  0002061a  2**0
                  CONTENTS, READONLY
252 .debug_aranges 000009f8  00000000  00000000  0002064b  2**0
                  CONTENTS, READONLY, DEBUGGING
253 .debug_info   00008e91  00000000  00000000  00021043  2**0
                  CONTENTS, READONLY, DEBUGGING
254 .debug_abbrev 00002e3a  00000000  00000000  00029ed4  2**0
                  CONTENTS, READONLY, DEBUGGING
255 .debug_line   00002f9c  00000000  00000000  0002cd0e  2**0
                  CONTENTS, READONLY, DEBUGGING
256 .debug_frame  00001d3c  00000000  00000000  0002fcac  2**2
                  CONTENTS, READONLY, DEBUGGING
257 .debug_str    00001c31  00000000  00000000  000319e8  2**0
                  CONTENTS, READONLY, DEBUGGING
258 .debug_loc    00005dea  00000000  00000000  00033619  2**0
                  CONTENTS, READONLY, DEBUGGING
259 .debug_ranges 00000aa0  00000000  00000000  00039403  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <gVectors>:
       0:	00 40 00 10 a1 13 00 00 e9 13 00 00 09 14 00 00     .@..............
      10:	59 14 00 00 79 14 00 00 99 14 00 00 00 00 00 00     Y...y...........
	...
      2c:	b9 14 00 00 d9 14 00 00 00 00 00 00 f9 14 00 00     ................
      3c:	d1 1a 00 00 19 15 00 00 39 15 00 00 59 15 00 00     ........9...Y...
      4c:	79 15 00 00 99 15 00 00 a5 1d 00 00 59 21 00 00     y...........Y!..
      5c:	b9 15 00 00 05 25 00 00 d9 15 00 00 f9 15 00 00     .....%..........
      6c:	19 16 00 00 39 16 00 00 59 16 00 00 79 16 00 00     ....9...Y...y...
      7c:	99 16 00 00 b9 16 00 00 d9 16 00 00 f9 16 00 00     ................
      8c:	19 17 00 00 39 17 00 00 59 17 00 00 79 17 00 00     ....9...Y...y...
      9c:	99 17 00 00 b9 17 00 00 d9 17 00 00 f9 17 00 00     ................
      ac:	19 18 00 00 39 18 00 00 59 18 00 00 79 18 00 00     ....9...Y...y...
      bc:	99 18 00 00 b9 18 00 00 d9 18 00 00 f9 18 00 00     ................
      cc:	19 19 00 00 39 19 00 00 59 19 00 00 79 19 00 00     ....9...Y...y...
      dc:	99 19 00 00 b9 19 00 00 00 00 00 00 00 00 00 00     ................
	...

000002fc <__aeabi_drsub>:
     2fc:	f081 4100 	eor.w	r1, r1, #2147483648	; 0x80000000
     300:	e002      	b.n	308 <__adddf3>
     302:	bf00      	nop

00000304 <__aeabi_dsub>:
     304:	f083 4300 	eor.w	r3, r3, #2147483648	; 0x80000000

00000308 <__adddf3>:
     308:	b530      	push	{r4, r5, lr}
     30a:	ea4f 0441 	mov.w	r4, r1, lsl #1
     30e:	ea4f 0543 	mov.w	r5, r3, lsl #1
     312:	ea94 0f05 	teq	r4, r5
     316:	bf08      	it	eq
     318:	ea90 0f02 	teqeq	r0, r2
     31c:	bf1f      	itttt	ne
     31e:	ea54 0c00 	orrsne.w	ip, r4, r0
     322:	ea55 0c02 	orrsne.w	ip, r5, r2
     326:	ea7f 5c64 	mvnsne.w	ip, r4, asr #21
     32a:	ea7f 5c65 	mvnsne.w	ip, r5, asr #21
     32e:	f000 80e2 	beq.w	4f6 <__adddf3+0x1ee>
     332:	ea4f 5454 	mov.w	r4, r4, lsr #21
     336:	ebd4 5555 	rsbs	r5, r4, r5, lsr #21
     33a:	bfb8      	it	lt
     33c:	426d      	neglt	r5, r5
     33e:	dd0c      	ble.n	35a <__adddf3+0x52>
     340:	442c      	add	r4, r5
     342:	ea80 0202 	eor.w	r2, r0, r2
     346:	ea81 0303 	eor.w	r3, r1, r3
     34a:	ea82 0000 	eor.w	r0, r2, r0
     34e:	ea83 0101 	eor.w	r1, r3, r1
     352:	ea80 0202 	eor.w	r2, r0, r2
     356:	ea81 0303 	eor.w	r3, r1, r3
     35a:	2d36      	cmp	r5, #54	; 0x36
     35c:	bf88      	it	hi
     35e:	bd30      	pophi	{r4, r5, pc}
     360:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     364:	ea4f 3101 	mov.w	r1, r1, lsl #12
     368:	f44f 1c80 	mov.w	ip, #1048576	; 0x100000
     36c:	ea4c 3111 	orr.w	r1, ip, r1, lsr #12
     370:	d002      	beq.n	378 <__adddf3+0x70>
     372:	4240      	negs	r0, r0
     374:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     378:	f013 4f00 	tst.w	r3, #2147483648	; 0x80000000
     37c:	ea4f 3303 	mov.w	r3, r3, lsl #12
     380:	ea4c 3313 	orr.w	r3, ip, r3, lsr #12
     384:	d002      	beq.n	38c <__adddf3+0x84>
     386:	4252      	negs	r2, r2
     388:	eb63 0343 	sbc.w	r3, r3, r3, lsl #1
     38c:	ea94 0f05 	teq	r4, r5
     390:	f000 80a7 	beq.w	4e2 <__adddf3+0x1da>
     394:	f1a4 0401 	sub.w	r4, r4, #1
     398:	f1d5 0e20 	rsbs	lr, r5, #32
     39c:	db0d      	blt.n	3ba <__adddf3+0xb2>
     39e:	fa02 fc0e 	lsl.w	ip, r2, lr
     3a2:	fa22 f205 	lsr.w	r2, r2, r5
     3a6:	1880      	adds	r0, r0, r2
     3a8:	f141 0100 	adc.w	r1, r1, #0
     3ac:	fa03 f20e 	lsl.w	r2, r3, lr
     3b0:	1880      	adds	r0, r0, r2
     3b2:	fa43 f305 	asr.w	r3, r3, r5
     3b6:	4159      	adcs	r1, r3
     3b8:	e00e      	b.n	3d8 <__adddf3+0xd0>
     3ba:	f1a5 0520 	sub.w	r5, r5, #32
     3be:	f10e 0e20 	add.w	lr, lr, #32
     3c2:	2a01      	cmp	r2, #1
     3c4:	fa03 fc0e 	lsl.w	ip, r3, lr
     3c8:	bf28      	it	cs
     3ca:	f04c 0c02 	orrcs.w	ip, ip, #2
     3ce:	fa43 f305 	asr.w	r3, r3, r5
     3d2:	18c0      	adds	r0, r0, r3
     3d4:	eb51 71e3 	adcs.w	r1, r1, r3, asr #31
     3d8:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     3dc:	d507      	bpl.n	3ee <__adddf3+0xe6>
     3de:	f04f 0e00 	mov.w	lr, #0
     3e2:	f1dc 0c00 	rsbs	ip, ip, #0
     3e6:	eb7e 0000 	sbcs.w	r0, lr, r0
     3ea:	eb6e 0101 	sbc.w	r1, lr, r1
     3ee:	f5b1 1f80 	cmp.w	r1, #1048576	; 0x100000
     3f2:	d31b      	bcc.n	42c <__adddf3+0x124>
     3f4:	f5b1 1f00 	cmp.w	r1, #2097152	; 0x200000
     3f8:	d30c      	bcc.n	414 <__adddf3+0x10c>
     3fa:	0849      	lsrs	r1, r1, #1
     3fc:	ea5f 0030 	movs.w	r0, r0, rrx
     400:	ea4f 0c3c 	mov.w	ip, ip, rrx
     404:	f104 0401 	add.w	r4, r4, #1
     408:	ea4f 5244 	mov.w	r2, r4, lsl #21
     40c:	f512 0f80 	cmn.w	r2, #4194304	; 0x400000
     410:	f080 809a 	bcs.w	548 <__adddf3+0x240>
     414:	f1bc 4f00 	cmp.w	ip, #2147483648	; 0x80000000
     418:	bf08      	it	eq
     41a:	ea5f 0c50 	movseq.w	ip, r0, lsr #1
     41e:	f150 0000 	adcs.w	r0, r0, #0
     422:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     426:	ea41 0105 	orr.w	r1, r1, r5
     42a:	bd30      	pop	{r4, r5, pc}
     42c:	ea5f 0c4c 	movs.w	ip, ip, lsl #1
     430:	4140      	adcs	r0, r0
     432:	eb41 0101 	adc.w	r1, r1, r1
     436:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     43a:	f1a4 0401 	sub.w	r4, r4, #1
     43e:	d1e9      	bne.n	414 <__adddf3+0x10c>
     440:	f091 0f00 	teq	r1, #0
     444:	bf04      	itt	eq
     446:	4601      	moveq	r1, r0
     448:	2000      	moveq	r0, #0
     44a:	fab1 f381 	clz	r3, r1
     44e:	bf08      	it	eq
     450:	3320      	addeq	r3, #32
     452:	f1a3 030b 	sub.w	r3, r3, #11
     456:	f1b3 0220 	subs.w	r2, r3, #32
     45a:	da0c      	bge.n	476 <__adddf3+0x16e>
     45c:	320c      	adds	r2, #12
     45e:	dd08      	ble.n	472 <__adddf3+0x16a>
     460:	f102 0c14 	add.w	ip, r2, #20
     464:	f1c2 020c 	rsb	r2, r2, #12
     468:	fa01 f00c 	lsl.w	r0, r1, ip
     46c:	fa21 f102 	lsr.w	r1, r1, r2
     470:	e00c      	b.n	48c <__adddf3+0x184>
     472:	f102 0214 	add.w	r2, r2, #20
     476:	bfd8      	it	le
     478:	f1c2 0c20 	rsble	ip, r2, #32
     47c:	fa01 f102 	lsl.w	r1, r1, r2
     480:	fa20 fc0c 	lsr.w	ip, r0, ip
     484:	bfdc      	itt	le
     486:	ea41 010c 	orrle.w	r1, r1, ip
     48a:	4090      	lslle	r0, r2
     48c:	1ae4      	subs	r4, r4, r3
     48e:	bfa2      	ittt	ge
     490:	eb01 5104 	addge.w	r1, r1, r4, lsl #20
     494:	4329      	orrge	r1, r5
     496:	bd30      	popge	{r4, r5, pc}
     498:	ea6f 0404 	mvn.w	r4, r4
     49c:	3c1f      	subs	r4, #31
     49e:	da1c      	bge.n	4da <__adddf3+0x1d2>
     4a0:	340c      	adds	r4, #12
     4a2:	dc0e      	bgt.n	4c2 <__adddf3+0x1ba>
     4a4:	f104 0414 	add.w	r4, r4, #20
     4a8:	f1c4 0220 	rsb	r2, r4, #32
     4ac:	fa20 f004 	lsr.w	r0, r0, r4
     4b0:	fa01 f302 	lsl.w	r3, r1, r2
     4b4:	ea40 0003 	orr.w	r0, r0, r3
     4b8:	fa21 f304 	lsr.w	r3, r1, r4
     4bc:	ea45 0103 	orr.w	r1, r5, r3
     4c0:	bd30      	pop	{r4, r5, pc}
     4c2:	f1c4 040c 	rsb	r4, r4, #12
     4c6:	f1c4 0220 	rsb	r2, r4, #32
     4ca:	fa20 f002 	lsr.w	r0, r0, r2
     4ce:	fa01 f304 	lsl.w	r3, r1, r4
     4d2:	ea40 0003 	orr.w	r0, r0, r3
     4d6:	4629      	mov	r1, r5
     4d8:	bd30      	pop	{r4, r5, pc}
     4da:	fa21 f004 	lsr.w	r0, r1, r4
     4de:	4629      	mov	r1, r5
     4e0:	bd30      	pop	{r4, r5, pc}
     4e2:	f094 0f00 	teq	r4, #0
     4e6:	f483 1380 	eor.w	r3, r3, #1048576	; 0x100000
     4ea:	bf06      	itte	eq
     4ec:	f481 1180 	eoreq.w	r1, r1, #1048576	; 0x100000
     4f0:	3401      	addeq	r4, #1
     4f2:	3d01      	subne	r5, #1
     4f4:	e74e      	b.n	394 <__adddf3+0x8c>
     4f6:	ea7f 5c64 	mvns.w	ip, r4, asr #21
     4fa:	bf18      	it	ne
     4fc:	ea7f 5c65 	mvnsne.w	ip, r5, asr #21
     500:	d029      	beq.n	556 <__adddf3+0x24e>
     502:	ea94 0f05 	teq	r4, r5
     506:	bf08      	it	eq
     508:	ea90 0f02 	teqeq	r0, r2
     50c:	d005      	beq.n	51a <__adddf3+0x212>
     50e:	ea54 0c00 	orrs.w	ip, r4, r0
     512:	bf04      	itt	eq
     514:	4619      	moveq	r1, r3
     516:	4610      	moveq	r0, r2
     518:	bd30      	pop	{r4, r5, pc}
     51a:	ea91 0f03 	teq	r1, r3
     51e:	bf1e      	ittt	ne
     520:	2100      	movne	r1, #0
     522:	2000      	movne	r0, #0
     524:	bd30      	popne	{r4, r5, pc}
     526:	ea5f 5c54 	movs.w	ip, r4, lsr #21
     52a:	d105      	bne.n	538 <__adddf3+0x230>
     52c:	0040      	lsls	r0, r0, #1
     52e:	4149      	adcs	r1, r1
     530:	bf28      	it	cs
     532:	f041 4100 	orrcs.w	r1, r1, #2147483648	; 0x80000000
     536:	bd30      	pop	{r4, r5, pc}
     538:	f514 0480 	adds.w	r4, r4, #4194304	; 0x400000
     53c:	bf3c      	itt	cc
     53e:	f501 1180 	addcc.w	r1, r1, #1048576	; 0x100000
     542:	bd30      	popcc	{r4, r5, pc}
     544:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     548:	f045 41fe 	orr.w	r1, r5, #2130706432	; 0x7f000000
     54c:	f441 0170 	orr.w	r1, r1, #15728640	; 0xf00000
     550:	f04f 0000 	mov.w	r0, #0
     554:	bd30      	pop	{r4, r5, pc}
     556:	ea7f 5c64 	mvns.w	ip, r4, asr #21
     55a:	bf1a      	itte	ne
     55c:	4619      	movne	r1, r3
     55e:	4610      	movne	r0, r2
     560:	ea7f 5c65 	mvnseq.w	ip, r5, asr #21
     564:	bf1c      	itt	ne
     566:	460b      	movne	r3, r1
     568:	4602      	movne	r2, r0
     56a:	ea50 3401 	orrs.w	r4, r0, r1, lsl #12
     56e:	bf06      	itte	eq
     570:	ea52 3503 	orrseq.w	r5, r2, r3, lsl #12
     574:	ea91 0f03 	teqeq	r1, r3
     578:	f441 2100 	orrne.w	r1, r1, #524288	; 0x80000
     57c:	bd30      	pop	{r4, r5, pc}
     57e:	bf00      	nop

00000580 <__aeabi_ui2d>:
     580:	f090 0f00 	teq	r0, #0
     584:	bf04      	itt	eq
     586:	2100      	moveq	r1, #0
     588:	4770      	bxeq	lr
     58a:	b530      	push	{r4, r5, lr}
     58c:	f44f 6480 	mov.w	r4, #1024	; 0x400
     590:	f104 0432 	add.w	r4, r4, #50	; 0x32
     594:	f04f 0500 	mov.w	r5, #0
     598:	f04f 0100 	mov.w	r1, #0
     59c:	e750      	b.n	440 <__adddf3+0x138>
     59e:	bf00      	nop

000005a0 <__aeabi_i2d>:
     5a0:	f090 0f00 	teq	r0, #0
     5a4:	bf04      	itt	eq
     5a6:	2100      	moveq	r1, #0
     5a8:	4770      	bxeq	lr
     5aa:	b530      	push	{r4, r5, lr}
     5ac:	f44f 6480 	mov.w	r4, #1024	; 0x400
     5b0:	f104 0432 	add.w	r4, r4, #50	; 0x32
     5b4:	f010 4500 	ands.w	r5, r0, #2147483648	; 0x80000000
     5b8:	bf48      	it	mi
     5ba:	4240      	negmi	r0, r0
     5bc:	f04f 0100 	mov.w	r1, #0
     5c0:	e73e      	b.n	440 <__adddf3+0x138>
     5c2:	bf00      	nop

000005c4 <__aeabi_f2d>:
     5c4:	0042      	lsls	r2, r0, #1
     5c6:	ea4f 01e2 	mov.w	r1, r2, asr #3
     5ca:	ea4f 0131 	mov.w	r1, r1, rrx
     5ce:	ea4f 7002 	mov.w	r0, r2, lsl #28
     5d2:	bf1f      	itttt	ne
     5d4:	f012 437f 	andsne.w	r3, r2, #4278190080	; 0xff000000
     5d8:	f093 4f7f 	teqne	r3, #4278190080	; 0xff000000
     5dc:	f081 5160 	eorne.w	r1, r1, #939524096	; 0x38000000
     5e0:	4770      	bxne	lr
     5e2:	f092 0f00 	teq	r2, #0
     5e6:	bf14      	ite	ne
     5e8:	f093 4f7f 	teqne	r3, #4278190080	; 0xff000000
     5ec:	4770      	bxeq	lr
     5ee:	b530      	push	{r4, r5, lr}
     5f0:	f44f 7460 	mov.w	r4, #896	; 0x380
     5f4:	f001 4500 	and.w	r5, r1, #2147483648	; 0x80000000
     5f8:	f021 4100 	bic.w	r1, r1, #2147483648	; 0x80000000
     5fc:	e720      	b.n	440 <__adddf3+0x138>
     5fe:	bf00      	nop

00000600 <__aeabi_ul2d>:
     600:	ea50 0201 	orrs.w	r2, r0, r1
     604:	bf08      	it	eq
     606:	4770      	bxeq	lr
     608:	b530      	push	{r4, r5, lr}
     60a:	f04f 0500 	mov.w	r5, #0
     60e:	e00a      	b.n	626 <__aeabi_l2d+0x16>

00000610 <__aeabi_l2d>:
     610:	ea50 0201 	orrs.w	r2, r0, r1
     614:	bf08      	it	eq
     616:	4770      	bxeq	lr
     618:	b530      	push	{r4, r5, lr}
     61a:	f011 4500 	ands.w	r5, r1, #2147483648	; 0x80000000
     61e:	d502      	bpl.n	626 <__aeabi_l2d+0x16>
     620:	4240      	negs	r0, r0
     622:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     626:	f44f 6480 	mov.w	r4, #1024	; 0x400
     62a:	f104 0432 	add.w	r4, r4, #50	; 0x32
     62e:	ea5f 5c91 	movs.w	ip, r1, lsr #22
     632:	f43f aedc 	beq.w	3ee <__adddf3+0xe6>
     636:	f04f 0203 	mov.w	r2, #3
     63a:	ea5f 0cdc 	movs.w	ip, ip, lsr #3
     63e:	bf18      	it	ne
     640:	3203      	addne	r2, #3
     642:	ea5f 0cdc 	movs.w	ip, ip, lsr #3
     646:	bf18      	it	ne
     648:	3203      	addne	r2, #3
     64a:	eb02 02dc 	add.w	r2, r2, ip, lsr #3
     64e:	f1c2 0320 	rsb	r3, r2, #32
     652:	fa00 fc03 	lsl.w	ip, r0, r3
     656:	fa20 f002 	lsr.w	r0, r0, r2
     65a:	fa01 fe03 	lsl.w	lr, r1, r3
     65e:	ea40 000e 	orr.w	r0, r0, lr
     662:	fa21 f102 	lsr.w	r1, r1, r2
     666:	4414      	add	r4, r2
     668:	e6c1      	b.n	3ee <__adddf3+0xe6>
     66a:	bf00      	nop

0000066c <__aeabi_dmul>:
     66c:	b570      	push	{r4, r5, r6, lr}
     66e:	f04f 0cff 	mov.w	ip, #255	; 0xff
     672:	f44c 6ce0 	orr.w	ip, ip, #1792	; 0x700
     676:	ea1c 5411 	ands.w	r4, ip, r1, lsr #20
     67a:	bf1d      	ittte	ne
     67c:	ea1c 5513 	andsne.w	r5, ip, r3, lsr #20
     680:	ea94 0f0c 	teqne	r4, ip
     684:	ea95 0f0c 	teqne	r5, ip
     688:	f000 f8de 	bleq	848 <__aeabi_dmul+0x1dc>
     68c:	442c      	add	r4, r5
     68e:	ea81 0603 	eor.w	r6, r1, r3
     692:	ea21 514c 	bic.w	r1, r1, ip, lsl #21
     696:	ea23 534c 	bic.w	r3, r3, ip, lsl #21
     69a:	ea50 3501 	orrs.w	r5, r0, r1, lsl #12
     69e:	bf18      	it	ne
     6a0:	ea52 3503 	orrsne.w	r5, r2, r3, lsl #12
     6a4:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     6a8:	f443 1380 	orr.w	r3, r3, #1048576	; 0x100000
     6ac:	d038      	beq.n	720 <__aeabi_dmul+0xb4>
     6ae:	fba0 ce02 	umull	ip, lr, r0, r2
     6b2:	f04f 0500 	mov.w	r5, #0
     6b6:	fbe1 e502 	umlal	lr, r5, r1, r2
     6ba:	f006 4200 	and.w	r2, r6, #2147483648	; 0x80000000
     6be:	fbe0 e503 	umlal	lr, r5, r0, r3
     6c2:	f04f 0600 	mov.w	r6, #0
     6c6:	fbe1 5603 	umlal	r5, r6, r1, r3
     6ca:	f09c 0f00 	teq	ip, #0
     6ce:	bf18      	it	ne
     6d0:	f04e 0e01 	orrne.w	lr, lr, #1
     6d4:	f1a4 04ff 	sub.w	r4, r4, #255	; 0xff
     6d8:	f5b6 7f00 	cmp.w	r6, #512	; 0x200
     6dc:	f564 7440 	sbc.w	r4, r4, #768	; 0x300
     6e0:	d204      	bcs.n	6ec <__aeabi_dmul+0x80>
     6e2:	ea5f 0e4e 	movs.w	lr, lr, lsl #1
     6e6:	416d      	adcs	r5, r5
     6e8:	eb46 0606 	adc.w	r6, r6, r6
     6ec:	ea42 21c6 	orr.w	r1, r2, r6, lsl #11
     6f0:	ea41 5155 	orr.w	r1, r1, r5, lsr #21
     6f4:	ea4f 20c5 	mov.w	r0, r5, lsl #11
     6f8:	ea40 505e 	orr.w	r0, r0, lr, lsr #21
     6fc:	ea4f 2ece 	mov.w	lr, lr, lsl #11
     700:	f1b4 0cfd 	subs.w	ip, r4, #253	; 0xfd
     704:	bf88      	it	hi
     706:	f5bc 6fe0 	cmphi.w	ip, #1792	; 0x700
     70a:	d81e      	bhi.n	74a <__aeabi_dmul+0xde>
     70c:	f1be 4f00 	cmp.w	lr, #2147483648	; 0x80000000
     710:	bf08      	it	eq
     712:	ea5f 0e50 	movseq.w	lr, r0, lsr #1
     716:	f150 0000 	adcs.w	r0, r0, #0
     71a:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     71e:	bd70      	pop	{r4, r5, r6, pc}
     720:	f006 4600 	and.w	r6, r6, #2147483648	; 0x80000000
     724:	ea46 0101 	orr.w	r1, r6, r1
     728:	ea40 0002 	orr.w	r0, r0, r2
     72c:	ea81 0103 	eor.w	r1, r1, r3
     730:	ebb4 045c 	subs.w	r4, r4, ip, lsr #1
     734:	bfc2      	ittt	gt
     736:	ebd4 050c 	rsbsgt	r5, r4, ip
     73a:	ea41 5104 	orrgt.w	r1, r1, r4, lsl #20
     73e:	bd70      	popgt	{r4, r5, r6, pc}
     740:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     744:	f04f 0e00 	mov.w	lr, #0
     748:	3c01      	subs	r4, #1
     74a:	f300 80ab 	bgt.w	8a4 <__aeabi_dmul+0x238>
     74e:	f114 0f36 	cmn.w	r4, #54	; 0x36
     752:	bfde      	ittt	le
     754:	2000      	movle	r0, #0
     756:	f001 4100 	andle.w	r1, r1, #2147483648	; 0x80000000
     75a:	bd70      	pople	{r4, r5, r6, pc}
     75c:	f1c4 0400 	rsb	r4, r4, #0
     760:	3c20      	subs	r4, #32
     762:	da35      	bge.n	7d0 <__aeabi_dmul+0x164>
     764:	340c      	adds	r4, #12
     766:	dc1b      	bgt.n	7a0 <__aeabi_dmul+0x134>
     768:	f104 0414 	add.w	r4, r4, #20
     76c:	f1c4 0520 	rsb	r5, r4, #32
     770:	fa00 f305 	lsl.w	r3, r0, r5
     774:	fa20 f004 	lsr.w	r0, r0, r4
     778:	fa01 f205 	lsl.w	r2, r1, r5
     77c:	ea40 0002 	orr.w	r0, r0, r2
     780:	f001 4200 	and.w	r2, r1, #2147483648	; 0x80000000
     784:	f021 4100 	bic.w	r1, r1, #2147483648	; 0x80000000
     788:	eb10 70d3 	adds.w	r0, r0, r3, lsr #31
     78c:	fa21 f604 	lsr.w	r6, r1, r4
     790:	eb42 0106 	adc.w	r1, r2, r6
     794:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     798:	bf08      	it	eq
     79a:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     79e:	bd70      	pop	{r4, r5, r6, pc}
     7a0:	f1c4 040c 	rsb	r4, r4, #12
     7a4:	f1c4 0520 	rsb	r5, r4, #32
     7a8:	fa00 f304 	lsl.w	r3, r0, r4
     7ac:	fa20 f005 	lsr.w	r0, r0, r5
     7b0:	fa01 f204 	lsl.w	r2, r1, r4
     7b4:	ea40 0002 	orr.w	r0, r0, r2
     7b8:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     7bc:	eb10 70d3 	adds.w	r0, r0, r3, lsr #31
     7c0:	f141 0100 	adc.w	r1, r1, #0
     7c4:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     7c8:	bf08      	it	eq
     7ca:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     7ce:	bd70      	pop	{r4, r5, r6, pc}
     7d0:	f1c4 0520 	rsb	r5, r4, #32
     7d4:	fa00 f205 	lsl.w	r2, r0, r5
     7d8:	ea4e 0e02 	orr.w	lr, lr, r2
     7dc:	fa20 f304 	lsr.w	r3, r0, r4
     7e0:	fa01 f205 	lsl.w	r2, r1, r5
     7e4:	ea43 0302 	orr.w	r3, r3, r2
     7e8:	fa21 f004 	lsr.w	r0, r1, r4
     7ec:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     7f0:	fa21 f204 	lsr.w	r2, r1, r4
     7f4:	ea20 0002 	bic.w	r0, r0, r2
     7f8:	eb00 70d3 	add.w	r0, r0, r3, lsr #31
     7fc:	ea5e 0e43 	orrs.w	lr, lr, r3, lsl #1
     800:	bf08      	it	eq
     802:	ea20 70d3 	biceq.w	r0, r0, r3, lsr #31
     806:	bd70      	pop	{r4, r5, r6, pc}
     808:	f094 0f00 	teq	r4, #0
     80c:	d10f      	bne.n	82e <__aeabi_dmul+0x1c2>
     80e:	f001 4600 	and.w	r6, r1, #2147483648	; 0x80000000
     812:	0040      	lsls	r0, r0, #1
     814:	eb41 0101 	adc.w	r1, r1, r1
     818:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     81c:	bf08      	it	eq
     81e:	3c01      	subeq	r4, #1
     820:	d0f7      	beq.n	812 <__aeabi_dmul+0x1a6>
     822:	ea41 0106 	orr.w	r1, r1, r6
     826:	f095 0f00 	teq	r5, #0
     82a:	bf18      	it	ne
     82c:	4770      	bxne	lr
     82e:	f003 4600 	and.w	r6, r3, #2147483648	; 0x80000000
     832:	0052      	lsls	r2, r2, #1
     834:	eb43 0303 	adc.w	r3, r3, r3
     838:	f413 1f80 	tst.w	r3, #1048576	; 0x100000
     83c:	bf08      	it	eq
     83e:	3d01      	subeq	r5, #1
     840:	d0f7      	beq.n	832 <__aeabi_dmul+0x1c6>
     842:	ea43 0306 	orr.w	r3, r3, r6
     846:	4770      	bx	lr
     848:	ea94 0f0c 	teq	r4, ip
     84c:	ea0c 5513 	and.w	r5, ip, r3, lsr #20
     850:	bf18      	it	ne
     852:	ea95 0f0c 	teqne	r5, ip
     856:	d00c      	beq.n	872 <__aeabi_dmul+0x206>
     858:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     85c:	bf18      	it	ne
     85e:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     862:	d1d1      	bne.n	808 <__aeabi_dmul+0x19c>
     864:	ea81 0103 	eor.w	r1, r1, r3
     868:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     86c:	f04f 0000 	mov.w	r0, #0
     870:	bd70      	pop	{r4, r5, r6, pc}
     872:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     876:	bf06      	itte	eq
     878:	4610      	moveq	r0, r2
     87a:	4619      	moveq	r1, r3
     87c:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     880:	d019      	beq.n	8b6 <__aeabi_dmul+0x24a>
     882:	ea94 0f0c 	teq	r4, ip
     886:	d102      	bne.n	88e <__aeabi_dmul+0x222>
     888:	ea50 3601 	orrs.w	r6, r0, r1, lsl #12
     88c:	d113      	bne.n	8b6 <__aeabi_dmul+0x24a>
     88e:	ea95 0f0c 	teq	r5, ip
     892:	d105      	bne.n	8a0 <__aeabi_dmul+0x234>
     894:	ea52 3603 	orrs.w	r6, r2, r3, lsl #12
     898:	bf1c      	itt	ne
     89a:	4610      	movne	r0, r2
     89c:	4619      	movne	r1, r3
     89e:	d10a      	bne.n	8b6 <__aeabi_dmul+0x24a>
     8a0:	ea81 0103 	eor.w	r1, r1, r3
     8a4:	f001 4100 	and.w	r1, r1, #2147483648	; 0x80000000
     8a8:	f041 41fe 	orr.w	r1, r1, #2130706432	; 0x7f000000
     8ac:	f441 0170 	orr.w	r1, r1, #15728640	; 0xf00000
     8b0:	f04f 0000 	mov.w	r0, #0
     8b4:	bd70      	pop	{r4, r5, r6, pc}
     8b6:	f041 41fe 	orr.w	r1, r1, #2130706432	; 0x7f000000
     8ba:	f441 0178 	orr.w	r1, r1, #16252928	; 0xf80000
     8be:	bd70      	pop	{r4, r5, r6, pc}

000008c0 <__aeabi_ddiv>:
     8c0:	b570      	push	{r4, r5, r6, lr}
     8c2:	f04f 0cff 	mov.w	ip, #255	; 0xff
     8c6:	f44c 6ce0 	orr.w	ip, ip, #1792	; 0x700
     8ca:	ea1c 5411 	ands.w	r4, ip, r1, lsr #20
     8ce:	bf1d      	ittte	ne
     8d0:	ea1c 5513 	andsne.w	r5, ip, r3, lsr #20
     8d4:	ea94 0f0c 	teqne	r4, ip
     8d8:	ea95 0f0c 	teqne	r5, ip
     8dc:	f000 f8a7 	bleq	a2e <__aeabi_ddiv+0x16e>
     8e0:	eba4 0405 	sub.w	r4, r4, r5
     8e4:	ea81 0e03 	eor.w	lr, r1, r3
     8e8:	ea52 3503 	orrs.w	r5, r2, r3, lsl #12
     8ec:	ea4f 3101 	mov.w	r1, r1, lsl #12
     8f0:	f000 8088 	beq.w	a04 <__aeabi_ddiv+0x144>
     8f4:	ea4f 3303 	mov.w	r3, r3, lsl #12
     8f8:	f04f 5580 	mov.w	r5, #268435456	; 0x10000000
     8fc:	ea45 1313 	orr.w	r3, r5, r3, lsr #4
     900:	ea43 6312 	orr.w	r3, r3, r2, lsr #24
     904:	ea4f 2202 	mov.w	r2, r2, lsl #8
     908:	ea45 1511 	orr.w	r5, r5, r1, lsr #4
     90c:	ea45 6510 	orr.w	r5, r5, r0, lsr #24
     910:	ea4f 2600 	mov.w	r6, r0, lsl #8
     914:	f00e 4100 	and.w	r1, lr, #2147483648	; 0x80000000
     918:	429d      	cmp	r5, r3
     91a:	bf08      	it	eq
     91c:	4296      	cmpeq	r6, r2
     91e:	f144 04fd 	adc.w	r4, r4, #253	; 0xfd
     922:	f504 7440 	add.w	r4, r4, #768	; 0x300
     926:	d202      	bcs.n	92e <__aeabi_ddiv+0x6e>
     928:	085b      	lsrs	r3, r3, #1
     92a:	ea4f 0232 	mov.w	r2, r2, rrx
     92e:	1ab6      	subs	r6, r6, r2
     930:	eb65 0503 	sbc.w	r5, r5, r3
     934:	085b      	lsrs	r3, r3, #1
     936:	ea4f 0232 	mov.w	r2, r2, rrx
     93a:	f44f 1080 	mov.w	r0, #1048576	; 0x100000
     93e:	f44f 2c00 	mov.w	ip, #524288	; 0x80000
     942:	ebb6 0e02 	subs.w	lr, r6, r2
     946:	eb75 0e03 	sbcs.w	lr, r5, r3
     94a:	bf22      	ittt	cs
     94c:	1ab6      	subcs	r6, r6, r2
     94e:	4675      	movcs	r5, lr
     950:	ea40 000c 	orrcs.w	r0, r0, ip
     954:	085b      	lsrs	r3, r3, #1
     956:	ea4f 0232 	mov.w	r2, r2, rrx
     95a:	ebb6 0e02 	subs.w	lr, r6, r2
     95e:	eb75 0e03 	sbcs.w	lr, r5, r3
     962:	bf22      	ittt	cs
     964:	1ab6      	subcs	r6, r6, r2
     966:	4675      	movcs	r5, lr
     968:	ea40 005c 	orrcs.w	r0, r0, ip, lsr #1
     96c:	085b      	lsrs	r3, r3, #1
     96e:	ea4f 0232 	mov.w	r2, r2, rrx
     972:	ebb6 0e02 	subs.w	lr, r6, r2
     976:	eb75 0e03 	sbcs.w	lr, r5, r3
     97a:	bf22      	ittt	cs
     97c:	1ab6      	subcs	r6, r6, r2
     97e:	4675      	movcs	r5, lr
     980:	ea40 009c 	orrcs.w	r0, r0, ip, lsr #2
     984:	085b      	lsrs	r3, r3, #1
     986:	ea4f 0232 	mov.w	r2, r2, rrx
     98a:	ebb6 0e02 	subs.w	lr, r6, r2
     98e:	eb75 0e03 	sbcs.w	lr, r5, r3
     992:	bf22      	ittt	cs
     994:	1ab6      	subcs	r6, r6, r2
     996:	4675      	movcs	r5, lr
     998:	ea40 00dc 	orrcs.w	r0, r0, ip, lsr #3
     99c:	ea55 0e06 	orrs.w	lr, r5, r6
     9a0:	d018      	beq.n	9d4 <__aeabi_ddiv+0x114>
     9a2:	ea4f 1505 	mov.w	r5, r5, lsl #4
     9a6:	ea45 7516 	orr.w	r5, r5, r6, lsr #28
     9aa:	ea4f 1606 	mov.w	r6, r6, lsl #4
     9ae:	ea4f 03c3 	mov.w	r3, r3, lsl #3
     9b2:	ea43 7352 	orr.w	r3, r3, r2, lsr #29
     9b6:	ea4f 02c2 	mov.w	r2, r2, lsl #3
     9ba:	ea5f 1c1c 	movs.w	ip, ip, lsr #4
     9be:	d1c0      	bne.n	942 <__aeabi_ddiv+0x82>
     9c0:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     9c4:	d10b      	bne.n	9de <__aeabi_ddiv+0x11e>
     9c6:	ea41 0100 	orr.w	r1, r1, r0
     9ca:	f04f 0000 	mov.w	r0, #0
     9ce:	f04f 4c00 	mov.w	ip, #2147483648	; 0x80000000
     9d2:	e7b6      	b.n	942 <__aeabi_ddiv+0x82>
     9d4:	f411 1f80 	tst.w	r1, #1048576	; 0x100000
     9d8:	bf04      	itt	eq
     9da:	4301      	orreq	r1, r0
     9dc:	2000      	moveq	r0, #0
     9de:	f1b4 0cfd 	subs.w	ip, r4, #253	; 0xfd
     9e2:	bf88      	it	hi
     9e4:	f5bc 6fe0 	cmphi.w	ip, #1792	; 0x700
     9e8:	f63f aeaf 	bhi.w	74a <__aeabi_dmul+0xde>
     9ec:	ebb5 0c03 	subs.w	ip, r5, r3
     9f0:	bf04      	itt	eq
     9f2:	ebb6 0c02 	subseq.w	ip, r6, r2
     9f6:	ea5f 0c50 	movseq.w	ip, r0, lsr #1
     9fa:	f150 0000 	adcs.w	r0, r0, #0
     9fe:	eb41 5104 	adc.w	r1, r1, r4, lsl #20
     a02:	bd70      	pop	{r4, r5, r6, pc}
     a04:	f00e 4e00 	and.w	lr, lr, #2147483648	; 0x80000000
     a08:	ea4e 3111 	orr.w	r1, lr, r1, lsr #12
     a0c:	eb14 045c 	adds.w	r4, r4, ip, lsr #1
     a10:	bfc2      	ittt	gt
     a12:	ebd4 050c 	rsbsgt	r5, r4, ip
     a16:	ea41 5104 	orrgt.w	r1, r1, r4, lsl #20
     a1a:	bd70      	popgt	{r4, r5, r6, pc}
     a1c:	f441 1180 	orr.w	r1, r1, #1048576	; 0x100000
     a20:	f04f 0e00 	mov.w	lr, #0
     a24:	3c01      	subs	r4, #1
     a26:	e690      	b.n	74a <__aeabi_dmul+0xde>
     a28:	ea45 0e06 	orr.w	lr, r5, r6
     a2c:	e68d      	b.n	74a <__aeabi_dmul+0xde>
     a2e:	ea0c 5513 	and.w	r5, ip, r3, lsr #20
     a32:	ea94 0f0c 	teq	r4, ip
     a36:	bf08      	it	eq
     a38:	ea95 0f0c 	teqeq	r5, ip
     a3c:	f43f af3b 	beq.w	8b6 <__aeabi_dmul+0x24a>
     a40:	ea94 0f0c 	teq	r4, ip
     a44:	d10a      	bne.n	a5c <__aeabi_ddiv+0x19c>
     a46:	ea50 3401 	orrs.w	r4, r0, r1, lsl #12
     a4a:	f47f af34 	bne.w	8b6 <__aeabi_dmul+0x24a>
     a4e:	ea95 0f0c 	teq	r5, ip
     a52:	f47f af25 	bne.w	8a0 <__aeabi_dmul+0x234>
     a56:	4610      	mov	r0, r2
     a58:	4619      	mov	r1, r3
     a5a:	e72c      	b.n	8b6 <__aeabi_dmul+0x24a>
     a5c:	ea95 0f0c 	teq	r5, ip
     a60:	d106      	bne.n	a70 <__aeabi_ddiv+0x1b0>
     a62:	ea52 3503 	orrs.w	r5, r2, r3, lsl #12
     a66:	f43f aefd 	beq.w	864 <__aeabi_dmul+0x1f8>
     a6a:	4610      	mov	r0, r2
     a6c:	4619      	mov	r1, r3
     a6e:	e722      	b.n	8b6 <__aeabi_dmul+0x24a>
     a70:	ea50 0641 	orrs.w	r6, r0, r1, lsl #1
     a74:	bf18      	it	ne
     a76:	ea52 0643 	orrsne.w	r6, r2, r3, lsl #1
     a7a:	f47f aec5 	bne.w	808 <__aeabi_dmul+0x19c>
     a7e:	ea50 0441 	orrs.w	r4, r0, r1, lsl #1
     a82:	f47f af0d 	bne.w	8a0 <__aeabi_dmul+0x234>
     a86:	ea52 0543 	orrs.w	r5, r2, r3, lsl #1
     a8a:	f47f aeeb 	bne.w	864 <__aeabi_dmul+0x1f8>
     a8e:	e712      	b.n	8b6 <__aeabi_dmul+0x24a>

00000a90 <__gedf2>:
     a90:	f04f 3cff 	mov.w	ip, #4294967295
     a94:	e006      	b.n	aa4 <__cmpdf2+0x4>
     a96:	bf00      	nop

00000a98 <__ledf2>:
     a98:	f04f 0c01 	mov.w	ip, #1
     a9c:	e002      	b.n	aa4 <__cmpdf2+0x4>
     a9e:	bf00      	nop

00000aa0 <__cmpdf2>:
     aa0:	f04f 0c01 	mov.w	ip, #1
     aa4:	f84d cd04 	str.w	ip, [sp, #-4]!
     aa8:	ea4f 0c41 	mov.w	ip, r1, lsl #1
     aac:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     ab0:	ea4f 0c43 	mov.w	ip, r3, lsl #1
     ab4:	bf18      	it	ne
     ab6:	ea7f 5c6c 	mvnsne.w	ip, ip, asr #21
     aba:	d01b      	beq.n	af4 <__cmpdf2+0x54>
     abc:	b001      	add	sp, #4
     abe:	ea50 0c41 	orrs.w	ip, r0, r1, lsl #1
     ac2:	bf0c      	ite	eq
     ac4:	ea52 0c43 	orrseq.w	ip, r2, r3, lsl #1
     ac8:	ea91 0f03 	teqne	r1, r3
     acc:	bf02      	ittt	eq
     ace:	ea90 0f02 	teqeq	r0, r2
     ad2:	2000      	moveq	r0, #0
     ad4:	4770      	bxeq	lr
     ad6:	f110 0f00 	cmn.w	r0, #0
     ada:	ea91 0f03 	teq	r1, r3
     ade:	bf58      	it	pl
     ae0:	4299      	cmppl	r1, r3
     ae2:	bf08      	it	eq
     ae4:	4290      	cmpeq	r0, r2
     ae6:	bf2c      	ite	cs
     ae8:	17d8      	asrcs	r0, r3, #31
     aea:	ea6f 70e3 	mvncc.w	r0, r3, asr #31
     aee:	f040 0001 	orr.w	r0, r0, #1
     af2:	4770      	bx	lr
     af4:	ea4f 0c41 	mov.w	ip, r1, lsl #1
     af8:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     afc:	d102      	bne.n	b04 <__cmpdf2+0x64>
     afe:	ea50 3c01 	orrs.w	ip, r0, r1, lsl #12
     b02:	d107      	bne.n	b14 <__cmpdf2+0x74>
     b04:	ea4f 0c43 	mov.w	ip, r3, lsl #1
     b08:	ea7f 5c6c 	mvns.w	ip, ip, asr #21
     b0c:	d1d6      	bne.n	abc <__cmpdf2+0x1c>
     b0e:	ea52 3c03 	orrs.w	ip, r2, r3, lsl #12
     b12:	d0d3      	beq.n	abc <__cmpdf2+0x1c>
     b14:	f85d 0b04 	ldr.w	r0, [sp], #4
     b18:	4770      	bx	lr
     b1a:	bf00      	nop

00000b1c <__aeabi_cdrcmple>:
     b1c:	4684      	mov	ip, r0
     b1e:	4610      	mov	r0, r2
     b20:	4662      	mov	r2, ip
     b22:	468c      	mov	ip, r1
     b24:	4619      	mov	r1, r3
     b26:	4663      	mov	r3, ip
     b28:	e000      	b.n	b2c <__aeabi_cdcmpeq>
     b2a:	bf00      	nop

00000b2c <__aeabi_cdcmpeq>:
     b2c:	b501      	push	{r0, lr}
     b2e:	f7ff ffb7 	bl	aa0 <__cmpdf2>
     b32:	2800      	cmp	r0, #0
     b34:	bf48      	it	mi
     b36:	f110 0f00 	cmnmi.w	r0, #0
     b3a:	bd01      	pop	{r0, pc}

00000b3c <__aeabi_dcmpeq>:
     b3c:	f84d ed08 	str.w	lr, [sp, #-8]!
     b40:	f7ff fff4 	bl	b2c <__aeabi_cdcmpeq>
     b44:	bf0c      	ite	eq
     b46:	2001      	moveq	r0, #1
     b48:	2000      	movne	r0, #0
     b4a:	f85d fb08 	ldr.w	pc, [sp], #8
     b4e:	bf00      	nop

00000b50 <__aeabi_dcmplt>:
     b50:	f84d ed08 	str.w	lr, [sp, #-8]!
     b54:	f7ff ffea 	bl	b2c <__aeabi_cdcmpeq>
     b58:	bf34      	ite	cc
     b5a:	2001      	movcc	r0, #1
     b5c:	2000      	movcs	r0, #0
     b5e:	f85d fb08 	ldr.w	pc, [sp], #8
     b62:	bf00      	nop

00000b64 <__aeabi_dcmple>:
     b64:	f84d ed08 	str.w	lr, [sp, #-8]!
     b68:	f7ff ffe0 	bl	b2c <__aeabi_cdcmpeq>
     b6c:	bf94      	ite	ls
     b6e:	2001      	movls	r0, #1
     b70:	2000      	movhi	r0, #0
     b72:	f85d fb08 	ldr.w	pc, [sp], #8
     b76:	bf00      	nop

00000b78 <__aeabi_dcmpge>:
     b78:	f84d ed08 	str.w	lr, [sp, #-8]!
     b7c:	f7ff ffce 	bl	b1c <__aeabi_cdrcmple>
     b80:	bf94      	ite	ls
     b82:	2001      	movls	r0, #1
     b84:	2000      	movhi	r0, #0
     b86:	f85d fb08 	ldr.w	pc, [sp], #8
     b8a:	bf00      	nop

00000b8c <__aeabi_dcmpgt>:
     b8c:	f84d ed08 	str.w	lr, [sp, #-8]!
     b90:	f7ff ffc4 	bl	b1c <__aeabi_cdrcmple>
     b94:	bf34      	ite	cc
     b96:	2001      	movcc	r0, #1
     b98:	2000      	movcs	r0, #0
     b9a:	f85d fb08 	ldr.w	pc, [sp], #8
     b9e:	bf00      	nop

00000ba0 <__aeabi_d2iz>:
     ba0:	ea4f 0241 	mov.w	r2, r1, lsl #1
     ba4:	f512 1200 	adds.w	r2, r2, #2097152	; 0x200000
     ba8:	d215      	bcs.n	bd6 <__aeabi_d2iz+0x36>
     baa:	d511      	bpl.n	bd0 <__aeabi_d2iz+0x30>
     bac:	f46f 7378 	mvn.w	r3, #992	; 0x3e0
     bb0:	ebb3 5262 	subs.w	r2, r3, r2, asr #21
     bb4:	d912      	bls.n	bdc <__aeabi_d2iz+0x3c>
     bb6:	ea4f 23c1 	mov.w	r3, r1, lsl #11
     bba:	f043 4300 	orr.w	r3, r3, #2147483648	; 0x80000000
     bbe:	ea43 5350 	orr.w	r3, r3, r0, lsr #21
     bc2:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     bc6:	fa23 f002 	lsr.w	r0, r3, r2
     bca:	bf18      	it	ne
     bcc:	4240      	negne	r0, r0
     bce:	4770      	bx	lr
     bd0:	f04f 0000 	mov.w	r0, #0
     bd4:	4770      	bx	lr
     bd6:	ea50 3001 	orrs.w	r0, r0, r1, lsl #12
     bda:	d105      	bne.n	be8 <__aeabi_d2iz+0x48>
     bdc:	f011 4000 	ands.w	r0, r1, #2147483648	; 0x80000000
     be0:	bf08      	it	eq
     be2:	f06f 4000 	mvneq.w	r0, #2147483648	; 0x80000000
     be6:	4770      	bx	lr
     be8:	f04f 0000 	mov.w	r0, #0
     bec:	4770      	bx	lr
     bee:	bf00      	nop

00000bf0 <__aeabi_frsub>:
     bf0:	f080 4000 	eor.w	r0, r0, #2147483648	; 0x80000000
     bf4:	e002      	b.n	bfc <__addsf3>
     bf6:	bf00      	nop

00000bf8 <__aeabi_fsub>:
     bf8:	f081 4100 	eor.w	r1, r1, #2147483648	; 0x80000000

00000bfc <__addsf3>:
     bfc:	0042      	lsls	r2, r0, #1
     bfe:	bf1f      	itttt	ne
     c00:	ea5f 0341 	movsne.w	r3, r1, lsl #1
     c04:	ea92 0f03 	teqne	r2, r3
     c08:	ea7f 6c22 	mvnsne.w	ip, r2, asr #24
     c0c:	ea7f 6c23 	mvnsne.w	ip, r3, asr #24
     c10:	d06a      	beq.n	ce8 <__addsf3+0xec>
     c12:	ea4f 6212 	mov.w	r2, r2, lsr #24
     c16:	ebd2 6313 	rsbs	r3, r2, r3, lsr #24
     c1a:	bfc1      	itttt	gt
     c1c:	18d2      	addgt	r2, r2, r3
     c1e:	4041      	eorgt	r1, r0
     c20:	4048      	eorgt	r0, r1
     c22:	4041      	eorgt	r1, r0
     c24:	bfb8      	it	lt
     c26:	425b      	neglt	r3, r3
     c28:	2b19      	cmp	r3, #25
     c2a:	bf88      	it	hi
     c2c:	4770      	bxhi	lr
     c2e:	f010 4f00 	tst.w	r0, #2147483648	; 0x80000000
     c32:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     c36:	f020 407f 	bic.w	r0, r0, #4278190080	; 0xff000000
     c3a:	bf18      	it	ne
     c3c:	4240      	negne	r0, r0
     c3e:	f011 4f00 	tst.w	r1, #2147483648	; 0x80000000
     c42:	f441 0100 	orr.w	r1, r1, #8388608	; 0x800000
     c46:	f021 417f 	bic.w	r1, r1, #4278190080	; 0xff000000
     c4a:	bf18      	it	ne
     c4c:	4249      	negne	r1, r1
     c4e:	ea92 0f03 	teq	r2, r3
     c52:	d03f      	beq.n	cd4 <__addsf3+0xd8>
     c54:	f1a2 0201 	sub.w	r2, r2, #1
     c58:	fa41 fc03 	asr.w	ip, r1, r3
     c5c:	eb10 000c 	adds.w	r0, r0, ip
     c60:	f1c3 0320 	rsb	r3, r3, #32
     c64:	fa01 f103 	lsl.w	r1, r1, r3
     c68:	f000 4300 	and.w	r3, r0, #2147483648	; 0x80000000
     c6c:	d502      	bpl.n	c74 <__addsf3+0x78>
     c6e:	4249      	negs	r1, r1
     c70:	eb60 0040 	sbc.w	r0, r0, r0, lsl #1
     c74:	f5b0 0f00 	cmp.w	r0, #8388608	; 0x800000
     c78:	d313      	bcc.n	ca2 <__addsf3+0xa6>
     c7a:	f1b0 7f80 	cmp.w	r0, #16777216	; 0x1000000
     c7e:	d306      	bcc.n	c8e <__addsf3+0x92>
     c80:	0840      	lsrs	r0, r0, #1
     c82:	ea4f 0131 	mov.w	r1, r1, rrx
     c86:	f102 0201 	add.w	r2, r2, #1
     c8a:	2afe      	cmp	r2, #254	; 0xfe
     c8c:	d251      	bcs.n	d32 <__addsf3+0x136>
     c8e:	f1b1 4f00 	cmp.w	r1, #2147483648	; 0x80000000
     c92:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
     c96:	bf08      	it	eq
     c98:	f020 0001 	biceq.w	r0, r0, #1
     c9c:	ea40 0003 	orr.w	r0, r0, r3
     ca0:	4770      	bx	lr
     ca2:	0049      	lsls	r1, r1, #1
     ca4:	eb40 0000 	adc.w	r0, r0, r0
     ca8:	f410 0f00 	tst.w	r0, #8388608	; 0x800000
     cac:	f1a2 0201 	sub.w	r2, r2, #1
     cb0:	d1ed      	bne.n	c8e <__addsf3+0x92>
     cb2:	fab0 fc80 	clz	ip, r0
     cb6:	f1ac 0c08 	sub.w	ip, ip, #8
     cba:	ebb2 020c 	subs.w	r2, r2, ip
     cbe:	fa00 f00c 	lsl.w	r0, r0, ip
     cc2:	bfaa      	itet	ge
     cc4:	eb00 50c2 	addge.w	r0, r0, r2, lsl #23
     cc8:	4252      	neglt	r2, r2
     cca:	4318      	orrge	r0, r3
     ccc:	bfbc      	itt	lt
     cce:	40d0      	lsrlt	r0, r2
     cd0:	4318      	orrlt	r0, r3
     cd2:	4770      	bx	lr
     cd4:	f092 0f00 	teq	r2, #0
     cd8:	f481 0100 	eor.w	r1, r1, #8388608	; 0x800000
     cdc:	bf06      	itte	eq
     cde:	f480 0000 	eoreq.w	r0, r0, #8388608	; 0x800000
     ce2:	3201      	addeq	r2, #1
     ce4:	3b01      	subne	r3, #1
     ce6:	e7b5      	b.n	c54 <__addsf3+0x58>
     ce8:	ea4f 0341 	mov.w	r3, r1, lsl #1
     cec:	ea7f 6c22 	mvns.w	ip, r2, asr #24
     cf0:	bf18      	it	ne
     cf2:	ea7f 6c23 	mvnsne.w	ip, r3, asr #24
     cf6:	d021      	beq.n	d3c <__addsf3+0x140>
     cf8:	ea92 0f03 	teq	r2, r3
     cfc:	d004      	beq.n	d08 <__addsf3+0x10c>
     cfe:	f092 0f00 	teq	r2, #0
     d02:	bf08      	it	eq
     d04:	4608      	moveq	r0, r1
     d06:	4770      	bx	lr
     d08:	ea90 0f01 	teq	r0, r1
     d0c:	bf1c      	itt	ne
     d0e:	2000      	movne	r0, #0
     d10:	4770      	bxne	lr
     d12:	f012 4f7f 	tst.w	r2, #4278190080	; 0xff000000
     d16:	d104      	bne.n	d22 <__addsf3+0x126>
     d18:	0040      	lsls	r0, r0, #1
     d1a:	bf28      	it	cs
     d1c:	f040 4000 	orrcs.w	r0, r0, #2147483648	; 0x80000000
     d20:	4770      	bx	lr
     d22:	f112 7200 	adds.w	r2, r2, #33554432	; 0x2000000
     d26:	bf3c      	itt	cc
     d28:	f500 0000 	addcc.w	r0, r0, #8388608	; 0x800000
     d2c:	4770      	bxcc	lr
     d2e:	f000 4300 	and.w	r3, r0, #2147483648	; 0x80000000
     d32:	f043 40fe 	orr.w	r0, r3, #2130706432	; 0x7f000000
     d36:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     d3a:	4770      	bx	lr
     d3c:	ea7f 6222 	mvns.w	r2, r2, asr #24
     d40:	bf16      	itet	ne
     d42:	4608      	movne	r0, r1
     d44:	ea7f 6323 	mvnseq.w	r3, r3, asr #24
     d48:	4601      	movne	r1, r0
     d4a:	0242      	lsls	r2, r0, #9
     d4c:	bf06      	itte	eq
     d4e:	ea5f 2341 	movseq.w	r3, r1, lsl #9
     d52:	ea90 0f01 	teqeq	r0, r1
     d56:	f440 0080 	orrne.w	r0, r0, #4194304	; 0x400000
     d5a:	4770      	bx	lr

00000d5c <__aeabi_ui2f>:
     d5c:	f04f 0300 	mov.w	r3, #0
     d60:	e004      	b.n	d6c <__aeabi_i2f+0x8>
     d62:	bf00      	nop

00000d64 <__aeabi_i2f>:
     d64:	f010 4300 	ands.w	r3, r0, #2147483648	; 0x80000000
     d68:	bf48      	it	mi
     d6a:	4240      	negmi	r0, r0
     d6c:	ea5f 0c00 	movs.w	ip, r0
     d70:	bf08      	it	eq
     d72:	4770      	bxeq	lr
     d74:	f043 4396 	orr.w	r3, r3, #1258291200	; 0x4b000000
     d78:	4601      	mov	r1, r0
     d7a:	f04f 0000 	mov.w	r0, #0
     d7e:	e01c      	b.n	dba <__aeabi_l2f+0x2a>

00000d80 <__aeabi_ul2f>:
     d80:	ea50 0201 	orrs.w	r2, r0, r1
     d84:	bf08      	it	eq
     d86:	4770      	bxeq	lr
     d88:	f04f 0300 	mov.w	r3, #0
     d8c:	e00a      	b.n	da4 <__aeabi_l2f+0x14>
     d8e:	bf00      	nop

00000d90 <__aeabi_l2f>:
     d90:	ea50 0201 	orrs.w	r2, r0, r1
     d94:	bf08      	it	eq
     d96:	4770      	bxeq	lr
     d98:	f011 4300 	ands.w	r3, r1, #2147483648	; 0x80000000
     d9c:	d502      	bpl.n	da4 <__aeabi_l2f+0x14>
     d9e:	4240      	negs	r0, r0
     da0:	eb61 0141 	sbc.w	r1, r1, r1, lsl #1
     da4:	ea5f 0c01 	movs.w	ip, r1
     da8:	bf02      	ittt	eq
     daa:	4684      	moveq	ip, r0
     dac:	4601      	moveq	r1, r0
     dae:	2000      	moveq	r0, #0
     db0:	f043 43b6 	orr.w	r3, r3, #1526726656	; 0x5b000000
     db4:	bf08      	it	eq
     db6:	f1a3 5380 	subeq.w	r3, r3, #268435456	; 0x10000000
     dba:	f5a3 0300 	sub.w	r3, r3, #8388608	; 0x800000
     dbe:	fabc f28c 	clz	r2, ip
     dc2:	3a08      	subs	r2, #8
     dc4:	eba3 53c2 	sub.w	r3, r3, r2, lsl #23
     dc8:	db10      	blt.n	dec <__aeabi_l2f+0x5c>
     dca:	fa01 fc02 	lsl.w	ip, r1, r2
     dce:	4463      	add	r3, ip
     dd0:	fa00 fc02 	lsl.w	ip, r0, r2
     dd4:	f1c2 0220 	rsb	r2, r2, #32
     dd8:	f1bc 4f00 	cmp.w	ip, #2147483648	; 0x80000000
     ddc:	fa20 f202 	lsr.w	r2, r0, r2
     de0:	eb43 0002 	adc.w	r0, r3, r2
     de4:	bf08      	it	eq
     de6:	f020 0001 	biceq.w	r0, r0, #1
     dea:	4770      	bx	lr
     dec:	f102 0220 	add.w	r2, r2, #32
     df0:	fa01 fc02 	lsl.w	ip, r1, r2
     df4:	f1c2 0220 	rsb	r2, r2, #32
     df8:	ea50 004c 	orrs.w	r0, r0, ip, lsl #1
     dfc:	fa21 f202 	lsr.w	r2, r1, r2
     e00:	eb43 0002 	adc.w	r0, r3, r2
     e04:	bf08      	it	eq
     e06:	ea20 70dc 	biceq.w	r0, r0, ip, lsr #31
     e0a:	4770      	bx	lr

00000e0c <__aeabi_fmul>:
     e0c:	f04f 0cff 	mov.w	ip, #255	; 0xff
     e10:	ea1c 52d0 	ands.w	r2, ip, r0, lsr #23
     e14:	bf1e      	ittt	ne
     e16:	ea1c 53d1 	andsne.w	r3, ip, r1, lsr #23
     e1a:	ea92 0f0c 	teqne	r2, ip
     e1e:	ea93 0f0c 	teqne	r3, ip
     e22:	d06f      	beq.n	f04 <__aeabi_fmul+0xf8>
     e24:	441a      	add	r2, r3
     e26:	ea80 0c01 	eor.w	ip, r0, r1
     e2a:	0240      	lsls	r0, r0, #9
     e2c:	bf18      	it	ne
     e2e:	ea5f 2141 	movsne.w	r1, r1, lsl #9
     e32:	d01e      	beq.n	e72 <__aeabi_fmul+0x66>
     e34:	f04f 6300 	mov.w	r3, #134217728	; 0x8000000
     e38:	ea43 1050 	orr.w	r0, r3, r0, lsr #5
     e3c:	ea43 1151 	orr.w	r1, r3, r1, lsr #5
     e40:	fba0 3101 	umull	r3, r1, r0, r1
     e44:	f00c 4000 	and.w	r0, ip, #2147483648	; 0x80000000
     e48:	f5b1 0f00 	cmp.w	r1, #8388608	; 0x800000
     e4c:	bf3e      	ittt	cc
     e4e:	0049      	lslcc	r1, r1, #1
     e50:	ea41 71d3 	orrcc.w	r1, r1, r3, lsr #31
     e54:	005b      	lslcc	r3, r3, #1
     e56:	ea40 0001 	orr.w	r0, r0, r1
     e5a:	f162 027f 	sbc.w	r2, r2, #127	; 0x7f
     e5e:	2afd      	cmp	r2, #253	; 0xfd
     e60:	d81d      	bhi.n	e9e <__aeabi_fmul+0x92>
     e62:	f1b3 4f00 	cmp.w	r3, #2147483648	; 0x80000000
     e66:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
     e6a:	bf08      	it	eq
     e6c:	f020 0001 	biceq.w	r0, r0, #1
     e70:	4770      	bx	lr
     e72:	f090 0f00 	teq	r0, #0
     e76:	f00c 4c00 	and.w	ip, ip, #2147483648	; 0x80000000
     e7a:	bf08      	it	eq
     e7c:	0249      	lsleq	r1, r1, #9
     e7e:	ea4c 2050 	orr.w	r0, ip, r0, lsr #9
     e82:	ea40 2051 	orr.w	r0, r0, r1, lsr #9
     e86:	3a7f      	subs	r2, #127	; 0x7f
     e88:	bfc2      	ittt	gt
     e8a:	f1d2 03ff 	rsbsgt	r3, r2, #255	; 0xff
     e8e:	ea40 50c2 	orrgt.w	r0, r0, r2, lsl #23
     e92:	4770      	bxgt	lr
     e94:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     e98:	f04f 0300 	mov.w	r3, #0
     e9c:	3a01      	subs	r2, #1
     e9e:	dc5d      	bgt.n	f5c <__aeabi_fmul+0x150>
     ea0:	f112 0f19 	cmn.w	r2, #25
     ea4:	bfdc      	itt	le
     ea6:	f000 4000 	andle.w	r0, r0, #2147483648	; 0x80000000
     eaa:	4770      	bxle	lr
     eac:	f1c2 0200 	rsb	r2, r2, #0
     eb0:	0041      	lsls	r1, r0, #1
     eb2:	fa21 f102 	lsr.w	r1, r1, r2
     eb6:	f1c2 0220 	rsb	r2, r2, #32
     eba:	fa00 fc02 	lsl.w	ip, r0, r2
     ebe:	ea5f 0031 	movs.w	r0, r1, rrx
     ec2:	f140 0000 	adc.w	r0, r0, #0
     ec6:	ea53 034c 	orrs.w	r3, r3, ip, lsl #1
     eca:	bf08      	it	eq
     ecc:	ea20 70dc 	biceq.w	r0, r0, ip, lsr #31
     ed0:	4770      	bx	lr
     ed2:	f092 0f00 	teq	r2, #0
     ed6:	f000 4c00 	and.w	ip, r0, #2147483648	; 0x80000000
     eda:	bf02      	ittt	eq
     edc:	0040      	lsleq	r0, r0, #1
     ede:	f410 0f00 	tsteq.w	r0, #8388608	; 0x800000
     ee2:	3a01      	subeq	r2, #1
     ee4:	d0f9      	beq.n	eda <__aeabi_fmul+0xce>
     ee6:	ea40 000c 	orr.w	r0, r0, ip
     eea:	f093 0f00 	teq	r3, #0
     eee:	f001 4c00 	and.w	ip, r1, #2147483648	; 0x80000000
     ef2:	bf02      	ittt	eq
     ef4:	0049      	lsleq	r1, r1, #1
     ef6:	f411 0f00 	tsteq.w	r1, #8388608	; 0x800000
     efa:	3b01      	subeq	r3, #1
     efc:	d0f9      	beq.n	ef2 <__aeabi_fmul+0xe6>
     efe:	ea41 010c 	orr.w	r1, r1, ip
     f02:	e78f      	b.n	e24 <__aeabi_fmul+0x18>
     f04:	ea0c 53d1 	and.w	r3, ip, r1, lsr #23
     f08:	ea92 0f0c 	teq	r2, ip
     f0c:	bf18      	it	ne
     f0e:	ea93 0f0c 	teqne	r3, ip
     f12:	d00a      	beq.n	f2a <__aeabi_fmul+0x11e>
     f14:	f030 4c00 	bics.w	ip, r0, #2147483648	; 0x80000000
     f18:	bf18      	it	ne
     f1a:	f031 4c00 	bicsne.w	ip, r1, #2147483648	; 0x80000000
     f1e:	d1d8      	bne.n	ed2 <__aeabi_fmul+0xc6>
     f20:	ea80 0001 	eor.w	r0, r0, r1
     f24:	f000 4000 	and.w	r0, r0, #2147483648	; 0x80000000
     f28:	4770      	bx	lr
     f2a:	f090 0f00 	teq	r0, #0
     f2e:	bf17      	itett	ne
     f30:	f090 4f00 	teqne	r0, #2147483648	; 0x80000000
     f34:	4608      	moveq	r0, r1
     f36:	f091 0f00 	teqne	r1, #0
     f3a:	f091 4f00 	teqne	r1, #2147483648	; 0x80000000
     f3e:	d014      	beq.n	f6a <__aeabi_fmul+0x15e>
     f40:	ea92 0f0c 	teq	r2, ip
     f44:	d101      	bne.n	f4a <__aeabi_fmul+0x13e>
     f46:	0242      	lsls	r2, r0, #9
     f48:	d10f      	bne.n	f6a <__aeabi_fmul+0x15e>
     f4a:	ea93 0f0c 	teq	r3, ip
     f4e:	d103      	bne.n	f58 <__aeabi_fmul+0x14c>
     f50:	024b      	lsls	r3, r1, #9
     f52:	bf18      	it	ne
     f54:	4608      	movne	r0, r1
     f56:	d108      	bne.n	f6a <__aeabi_fmul+0x15e>
     f58:	ea80 0001 	eor.w	r0, r0, r1
     f5c:	f000 4000 	and.w	r0, r0, #2147483648	; 0x80000000
     f60:	f040 40fe 	orr.w	r0, r0, #2130706432	; 0x7f000000
     f64:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
     f68:	4770      	bx	lr
     f6a:	f040 40fe 	orr.w	r0, r0, #2130706432	; 0x7f000000
     f6e:	f440 0040 	orr.w	r0, r0, #12582912	; 0xc00000
     f72:	4770      	bx	lr

00000f74 <__aeabi_fdiv>:
     f74:	f04f 0cff 	mov.w	ip, #255	; 0xff
     f78:	ea1c 52d0 	ands.w	r2, ip, r0, lsr #23
     f7c:	bf1e      	ittt	ne
     f7e:	ea1c 53d1 	andsne.w	r3, ip, r1, lsr #23
     f82:	ea92 0f0c 	teqne	r2, ip
     f86:	ea93 0f0c 	teqne	r3, ip
     f8a:	d069      	beq.n	1060 <__aeabi_fdiv+0xec>
     f8c:	eba2 0203 	sub.w	r2, r2, r3
     f90:	ea80 0c01 	eor.w	ip, r0, r1
     f94:	0249      	lsls	r1, r1, #9
     f96:	ea4f 2040 	mov.w	r0, r0, lsl #9
     f9a:	d037      	beq.n	100c <__aeabi_fdiv+0x98>
     f9c:	f04f 5380 	mov.w	r3, #268435456	; 0x10000000
     fa0:	ea43 1111 	orr.w	r1, r3, r1, lsr #4
     fa4:	ea43 1310 	orr.w	r3, r3, r0, lsr #4
     fa8:	f00c 4000 	and.w	r0, ip, #2147483648	; 0x80000000
     fac:	428b      	cmp	r3, r1
     fae:	bf38      	it	cc
     fb0:	005b      	lslcc	r3, r3, #1
     fb2:	f142 027d 	adc.w	r2, r2, #125	; 0x7d
     fb6:	f44f 0c00 	mov.w	ip, #8388608	; 0x800000
     fba:	428b      	cmp	r3, r1
     fbc:	bf24      	itt	cs
     fbe:	1a5b      	subcs	r3, r3, r1
     fc0:	ea40 000c 	orrcs.w	r0, r0, ip
     fc4:	ebb3 0f51 	cmp.w	r3, r1, lsr #1
     fc8:	bf24      	itt	cs
     fca:	eba3 0351 	subcs.w	r3, r3, r1, lsr #1
     fce:	ea40 005c 	orrcs.w	r0, r0, ip, lsr #1
     fd2:	ebb3 0f91 	cmp.w	r3, r1, lsr #2
     fd6:	bf24      	itt	cs
     fd8:	eba3 0391 	subcs.w	r3, r3, r1, lsr #2
     fdc:	ea40 009c 	orrcs.w	r0, r0, ip, lsr #2
     fe0:	ebb3 0fd1 	cmp.w	r3, r1, lsr #3
     fe4:	bf24      	itt	cs
     fe6:	eba3 03d1 	subcs.w	r3, r3, r1, lsr #3
     fea:	ea40 00dc 	orrcs.w	r0, r0, ip, lsr #3
     fee:	011b      	lsls	r3, r3, #4
     ff0:	bf18      	it	ne
     ff2:	ea5f 1c1c 	movsne.w	ip, ip, lsr #4
     ff6:	d1e0      	bne.n	fba <__aeabi_fdiv+0x46>
     ff8:	2afd      	cmp	r2, #253	; 0xfd
     ffa:	f63f af50 	bhi.w	e9e <__aeabi_fmul+0x92>
     ffe:	428b      	cmp	r3, r1
    1000:	eb40 50c2 	adc.w	r0, r0, r2, lsl #23
    1004:	bf08      	it	eq
    1006:	f020 0001 	biceq.w	r0, r0, #1
    100a:	4770      	bx	lr
    100c:	f00c 4c00 	and.w	ip, ip, #2147483648	; 0x80000000
    1010:	ea4c 2050 	orr.w	r0, ip, r0, lsr #9
    1014:	327f      	adds	r2, #127	; 0x7f
    1016:	bfc2      	ittt	gt
    1018:	f1d2 03ff 	rsbsgt	r3, r2, #255	; 0xff
    101c:	ea40 50c2 	orrgt.w	r0, r0, r2, lsl #23
    1020:	4770      	bxgt	lr
    1022:	f440 0000 	orr.w	r0, r0, #8388608	; 0x800000
    1026:	f04f 0300 	mov.w	r3, #0
    102a:	3a01      	subs	r2, #1
    102c:	e737      	b.n	e9e <__aeabi_fmul+0x92>
    102e:	f092 0f00 	teq	r2, #0
    1032:	f000 4c00 	and.w	ip, r0, #2147483648	; 0x80000000
    1036:	bf02      	ittt	eq
    1038:	0040      	lsleq	r0, r0, #1
    103a:	f410 0f00 	tsteq.w	r0, #8388608	; 0x800000
    103e:	3a01      	subeq	r2, #1
    1040:	d0f9      	beq.n	1036 <__aeabi_fdiv+0xc2>
    1042:	ea40 000c 	orr.w	r0, r0, ip
    1046:	f093 0f00 	teq	r3, #0
    104a:	f001 4c00 	and.w	ip, r1, #2147483648	; 0x80000000
    104e:	bf02      	ittt	eq
    1050:	0049      	lsleq	r1, r1, #1
    1052:	f411 0f00 	tsteq.w	r1, #8388608	; 0x800000
    1056:	3b01      	subeq	r3, #1
    1058:	d0f9      	beq.n	104e <__aeabi_fdiv+0xda>
    105a:	ea41 010c 	orr.w	r1, r1, ip
    105e:	e795      	b.n	f8c <__aeabi_fdiv+0x18>
    1060:	ea0c 53d1 	and.w	r3, ip, r1, lsr #23
    1064:	ea92 0f0c 	teq	r2, ip
    1068:	d108      	bne.n	107c <__aeabi_fdiv+0x108>
    106a:	0242      	lsls	r2, r0, #9
    106c:	f47f af7d 	bne.w	f6a <__aeabi_fmul+0x15e>
    1070:	ea93 0f0c 	teq	r3, ip
    1074:	f47f af70 	bne.w	f58 <__aeabi_fmul+0x14c>
    1078:	4608      	mov	r0, r1
    107a:	e776      	b.n	f6a <__aeabi_fmul+0x15e>
    107c:	ea93 0f0c 	teq	r3, ip
    1080:	d104      	bne.n	108c <__aeabi_fdiv+0x118>
    1082:	024b      	lsls	r3, r1, #9
    1084:	f43f af4c 	beq.w	f20 <__aeabi_fmul+0x114>
    1088:	4608      	mov	r0, r1
    108a:	e76e      	b.n	f6a <__aeabi_fmul+0x15e>
    108c:	f030 4c00 	bics.w	ip, r0, #2147483648	; 0x80000000
    1090:	bf18      	it	ne
    1092:	f031 4c00 	bicsne.w	ip, r1, #2147483648	; 0x80000000
    1096:	d1ca      	bne.n	102e <__aeabi_fdiv+0xba>
    1098:	f030 4200 	bics.w	r2, r0, #2147483648	; 0x80000000
    109c:	f47f af5c 	bne.w	f58 <__aeabi_fmul+0x14c>
    10a0:	f031 4300 	bics.w	r3, r1, #2147483648	; 0x80000000
    10a4:	f47f af3c 	bne.w	f20 <__aeabi_fmul+0x114>
    10a8:	e75f      	b.n	f6a <__aeabi_fmul+0x15e>
    10aa:	bf00      	nop

000010ac <strcmp>:
    10ac:	ea80 0c01 	eor.w	ip, r0, r1
    10b0:	f01c 0f03 	tst.w	ip, #3
    10b4:	d137      	bne.n	1126 <strcmp+0x7a>
    10b6:	f010 0c03 	ands.w	ip, r0, #3
    10ba:	f020 0003 	bic.w	r0, r0, #3
    10be:	f021 0103 	bic.w	r1, r1, #3
    10c2:	f850 2b04 	ldr.w	r2, [r0], #4
    10c6:	bf08      	it	eq
    10c8:	f851 3b04 	ldreq.w	r3, [r1], #4
    10cc:	d00e      	beq.n	10ec <strcmp+0x40>
    10ce:	f08c 0c03 	eor.w	ip, ip, #3
    10d2:	f06f 437f 	mvn.w	r3, #4278190080	; 0xff000000
    10d6:	ea4f 0ccc 	mov.w	ip, ip, lsl #3
    10da:	fa23 fc0c 	lsr.w	ip, r3, ip
    10de:	f851 3b04 	ldr.w	r3, [r1], #4
    10e2:	ea42 020c 	orr.w	r2, r2, ip
    10e6:	ea43 030c 	orr.w	r3, r3, ip
    10ea:	bf00      	nop
    10ec:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    10f0:	429a      	cmp	r2, r3
    10f2:	bf01      	itttt	eq
    10f4:	ea2c 0c02 	biceq.w	ip, ip, r2
    10f8:	f01c 3f80 	tsteq.w	ip, #2155905152	; 0x80808080
    10fc:	f850 2b04 	ldreq.w	r2, [r0], #4
    1100:	f851 3b04 	ldreq.w	r3, [r1], #4
    1104:	d0f2      	beq.n	10ec <strcmp+0x40>
    1106:	ea4f 6002 	mov.w	r0, r2, lsl #24
    110a:	ea4f 2212 	mov.w	r2, r2, lsr #8
    110e:	2801      	cmp	r0, #1
    1110:	bf28      	it	cs
    1112:	ebb0 6f03 	cmpcs.w	r0, r3, lsl #24
    1116:	bf08      	it	eq
    1118:	0a1b      	lsreq	r3, r3, #8
    111a:	d0f4      	beq.n	1106 <strcmp+0x5a>
    111c:	f003 03ff 	and.w	r3, r3, #255	; 0xff
    1120:	0e00      	lsrs	r0, r0, #24
    1122:	1ac0      	subs	r0, r0, r3
    1124:	4770      	bx	lr
    1126:	f010 0f03 	tst.w	r0, #3
    112a:	d00a      	beq.n	1142 <strcmp+0x96>
    112c:	f810 2b01 	ldrb.w	r2, [r0], #1
    1130:	f811 3b01 	ldrb.w	r3, [r1], #1
    1134:	2a01      	cmp	r2, #1
    1136:	bf28      	it	cs
    1138:	429a      	cmpcs	r2, r3
    113a:	d0f4      	beq.n	1126 <strcmp+0x7a>
    113c:	eba2 0003 	sub.w	r0, r2, r3
    1140:	4770      	bx	lr
    1142:	f84d 5d04 	str.w	r5, [sp, #-4]!
    1146:	f850 2b04 	ldr.w	r2, [r0], #4
    114a:	f001 0503 	and.w	r5, r1, #3
    114e:	f021 0103 	bic.w	r1, r1, #3
    1152:	f851 3b04 	ldr.w	r3, [r1], #4
    1156:	2d02      	cmp	r5, #2
    1158:	d026      	beq.n	11a8 <strcmp+0xfc>
    115a:	d84d      	bhi.n	11f8 <strcmp+0x14c>
    115c:	f022 457f 	bic.w	r5, r2, #4278190080	; 0xff000000
    1160:	ebb5 2f13 	cmp.w	r5, r3, lsr #8
    1164:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    1168:	ea2c 0c02 	bic.w	ip, ip, r2
    116c:	d10d      	bne.n	118a <strcmp+0xde>
    116e:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    1172:	bf08      	it	eq
    1174:	f851 3b04 	ldreq.w	r3, [r1], #4
    1178:	d10a      	bne.n	1190 <strcmp+0xe4>
    117a:	ea85 0502 	eor.w	r5, r5, r2
    117e:	ebb5 6f03 	cmp.w	r5, r3, lsl #24
    1182:	d10c      	bne.n	119e <strcmp+0xf2>
    1184:	f850 2b04 	ldr.w	r2, [r0], #4
    1188:	e7e8      	b.n	115c <strcmp+0xb0>
    118a:	ea4f 2313 	mov.w	r3, r3, lsr #8
    118e:	e05b      	b.n	1248 <strcmp+0x19c>
    1190:	f03c 4c7f 	bics.w	ip, ip, #4278190080	; 0xff000000
    1194:	d154      	bne.n	1240 <strcmp+0x194>
    1196:	780b      	ldrb	r3, [r1, #0]
    1198:	ea4f 6512 	mov.w	r5, r2, lsr #24
    119c:	e054      	b.n	1248 <strcmp+0x19c>
    119e:	ea4f 6512 	mov.w	r5, r2, lsr #24
    11a2:	f003 03ff 	and.w	r3, r3, #255	; 0xff
    11a6:	e04f      	b.n	1248 <strcmp+0x19c>
    11a8:	ea4f 4502 	mov.w	r5, r2, lsl #16
    11ac:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    11b0:	ea4f 4515 	mov.w	r5, r5, lsr #16
    11b4:	ea2c 0c02 	bic.w	ip, ip, r2
    11b8:	ebb5 4f13 	cmp.w	r5, r3, lsr #16
    11bc:	d118      	bne.n	11f0 <strcmp+0x144>
    11be:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    11c2:	bf08      	it	eq
    11c4:	f851 3b04 	ldreq.w	r3, [r1], #4
    11c8:	d107      	bne.n	11da <strcmp+0x12e>
    11ca:	ea85 0502 	eor.w	r5, r5, r2
    11ce:	ebb5 4f03 	cmp.w	r5, r3, lsl #16
    11d2:	d109      	bne.n	11e8 <strcmp+0x13c>
    11d4:	f850 2b04 	ldr.w	r2, [r0], #4
    11d8:	e7e6      	b.n	11a8 <strcmp+0xfc>
    11da:	ea5f 4c0c 	movs.w	ip, ip, lsl #16
    11de:	d12f      	bne.n	1240 <strcmp+0x194>
    11e0:	880b      	ldrh	r3, [r1, #0]
    11e2:	ea4f 4512 	mov.w	r5, r2, lsr #16
    11e6:	e02f      	b.n	1248 <strcmp+0x19c>
    11e8:	ea4f 4303 	mov.w	r3, r3, lsl #16
    11ec:	ea4f 4512 	mov.w	r5, r2, lsr #16
    11f0:	ea4f 4313 	mov.w	r3, r3, lsr #16
    11f4:	e028      	b.n	1248 <strcmp+0x19c>
    11f6:	bf00      	nop
    11f8:	f002 05ff 	and.w	r5, r2, #255	; 0xff
    11fc:	ebb5 6f13 	cmp.w	r5, r3, lsr #24
    1200:	f1a2 3c01 	sub.w	ip, r2, #16843009	; 0x1010101
    1204:	ea2c 0c02 	bic.w	ip, ip, r2
    1208:	d10d      	bne.n	1226 <strcmp+0x17a>
    120a:	f01c 3c80 	ands.w	ip, ip, #2155905152	; 0x80808080
    120e:	bf08      	it	eq
    1210:	f851 3b04 	ldreq.w	r3, [r1], #4
    1214:	d10a      	bne.n	122c <strcmp+0x180>
    1216:	ea85 0502 	eor.w	r5, r5, r2
    121a:	ebb5 2f03 	cmp.w	r5, r3, lsl #8
    121e:	d10a      	bne.n	1236 <strcmp+0x18a>
    1220:	f850 2b04 	ldr.w	r2, [r0], #4
    1224:	e7e8      	b.n	11f8 <strcmp+0x14c>
    1226:	ea4f 6313 	mov.w	r3, r3, lsr #24
    122a:	e00d      	b.n	1248 <strcmp+0x19c>
    122c:	f012 0fff 	tst.w	r2, #255	; 0xff
    1230:	d006      	beq.n	1240 <strcmp+0x194>
    1232:	f851 3b04 	ldr.w	r3, [r1], #4
    1236:	ea4f 2512 	mov.w	r5, r2, lsr #8
    123a:	f023 437f 	bic.w	r3, r3, #4278190080	; 0xff000000
    123e:	e003      	b.n	1248 <strcmp+0x19c>
    1240:	f04f 0000 	mov.w	r0, #0
    1244:	bc20      	pop	{r5}
    1246:	4770      	bx	lr
    1248:	f005 02ff 	and.w	r2, r5, #255	; 0xff
    124c:	f003 00ff 	and.w	r0, r3, #255	; 0xff
    1250:	2801      	cmp	r0, #1
    1252:	bf28      	it	cs
    1254:	4290      	cmpcs	r0, r2
    1256:	bf04      	itt	eq
    1258:	0a2d      	lsreq	r5, r5, #8
    125a:	0a1b      	lsreq	r3, r3, #8
    125c:	d0f4      	beq.n	1248 <strcmp+0x19c>
    125e:	eba2 0000 	sub.w	r0, r2, r0
    1262:	bc20      	pop	{r5}
    1264:	4770      	bx	lr
    1266:	bf00      	nop

Disassembly of section .text.arm_Init:

00001268 <arm_Init>:
		// --------------------------------------------------
		#if defined (arm7tdmi)
		MEMMAP = MEMMAP_FLASH;
		#endif
		#if defined (cortexm3)
		vtor_SetInCode(0); // Definir a tabela de ints no endereço 0 da flash
    1268:	4b3e      	ldr	r3, [pc, #248]	; (1364 <arm_Init+0xfc>)
    126a:	2000      	movs	r0, #0

// -----------------------------------------------------------------------------------------------
// Descrição:	Incialiaza clock do processador e dos barramentos através do STARTUP
// ajustes no makefile 	
// -----------------------------------------------------------------------------------------------
void arm_Init (void) {
    126c:	b570      	push	{r4, r5, r6, lr}
		// --------------------------------------------------
		#if defined (arm7tdmi)
		MEMMAP = MEMMAP_FLASH;
		#endif
		#if defined (cortexm3)
		vtor_SetInCode(0); // Definir a tabela de ints no endereço 0 da flash
    126e:	6018      	str	r0, [r3, #0]
	//		Pois, isto economiza energia
	#if defined (arm7tdmi)
	PCONP = 0;
	#endif
	#if defined (cortexm3)
	PCONP = PCGPIO; // Vamos deixar somente o GPIO habilitado, pois este habilita também os IOCONS (pinsel)
    1270:	4b3d      	ldr	r3, [pc, #244]	; (1368 <arm_Init+0x100>)
    1272:	f44f 4200 	mov.w	r2, #32768	; 0x8000
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    1276:	493d      	ldr	r1, [pc, #244]	; (136c <arm_Init+0x104>)
	//		Pois, isto economiza energia
	#if defined (arm7tdmi)
	PCONP = 0;
	#endif
	#if defined (cortexm3)
	PCONP = PCGPIO; // Vamos deixar somente o GPIO habilitado, pois este habilita também os IOCONS (pinsel)
    1278:	601a      	str	r2, [r3, #0]
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    127a:	680b      	ldr	r3, [r1, #0]
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
    127c:	4a3c      	ldr	r2, [pc, #240]	; (1370 <arm_Init+0x108>)
	cclksel_sysClk();  // Seleciona o oscilador RC para o divisor do CCLK, PCLK e MEMCLK
	cclksel_clkDiv(1); // Divisor 1:1 para o CCLK
	#endif

	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
    127e:	f023 03ff 	bic.w	r3, r3, #255	; 0xff
    1282:	f043 0301 	orr.w	r3, r3, #1
    1286:	600b      	str	r3, [r1, #0]
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
	scs_oscOFF(); 							// Desabiltar o osc MAIN
    1288:	4b3a      	ldr	r3, [pc, #232]	; (1374 <arm_Init+0x10c>)
	#if defined(LPC1751) || defined(LPC1752)
	cclksel_clkDiv(2); 						// Divisor 1:1 para o CCLK
	#endif

	#if defined(OSC_XTAL)
	clksrcsel_oscRC(); 						// habilitar o oscilador RC interno para o sistema
    128a:	6010      	str	r0, [r2, #0]
	scs_oscOFF(); 							// Desabiltar o osc MAIN
    128c:	6818      	ldr	r0, [r3, #0]
    128e:	f020 0020 	bic.w	r0, r0, #32
    1292:	6018      	str	r0, [r3, #0]
	#if (F_CPU > 20000000)
	SCS |= SCS_OSCRANGE_15MHZ_25MHZ;
	#endif
  	scs_oscON();							// Liga o oscilador MAIN
    1294:	6818      	ldr	r0, [r3, #0]
    1296:	f040 0020 	orr.w	r0, r0, #32
    129a:	6018      	str	r0, [r3, #0]
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
    129c:	6818      	ldr	r0, [r3, #0]
    129e:	0640      	lsls	r0, r0, #25
    12a0:	d5fc      	bpl.n	129c <arm_Init+0x34>
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
    12a2:	2301      	movs	r3, #1
    12a4:	6013      	str	r3, [r2, #0]
  	#endif

  	pll_OFF(); 								// Desabilita PLL
    12a6:	4a34      	ldr	r2, [pc, #208]	; (1378 <arm_Init+0x110>)
    12a8:	2300      	movs	r3, #0
    12aa:	6013      	str	r3, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12ac:	4d33      	ldr	r5, [pc, #204]	; (137c <arm_Init+0x114>)
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
  	#endif

  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12ae:	4b34      	ldr	r3, [pc, #208]	; (1380 <arm_Init+0x118>)
    12b0:	24aa      	movs	r4, #170	; 0xaa
    12b2:	2055      	movs	r0, #85	; 0x55
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12b4:	260e      	movs	r6, #14
  	while( !(SCS & SCS_OSCSTAT) );			// Espero até que o oscilador principal esteja pronto para uso como fonte de clock para o PLL
  	clksrcsel_oscMAIN(); 					// Habilita o oscilador MAIN para o sistema
  	#endif

  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12b6:	601c      	str	r4, [r3, #0]
    12b8:	6018      	str	r0, [r3, #0]
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
    12ba:	602e      	str	r6, [r5, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12bc:	601c      	str	r4, [r3, #0]
    12be:	6018      	str	r0, [r3, #0]
  	pll_ON();								// Habilita PLL
    12c0:	6815      	ldr	r5, [r2, #0]
    12c2:	f045 0501 	orr.w	r5, r5, #1
    12c6:	6015      	str	r5, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG

  	while (!(PLLSTAT & PLLSTAT_LOCK));		// Espera que o PLL trave. No Skyeye não se usa
    12c8:	4d2e      	ldr	r5, [pc, #184]	; (1384 <arm_Init+0x11c>)
  	pll_OFF(); 								// Desabilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLLCFG = PLLCFG_MSEL | PLLCFG_PSEL;		// Ajustando o multiplicador e divisor do PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	pll_ON();								// Habilita PLL
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12ca:	601c      	str	r4, [r3, #0]
    12cc:	6018      	str	r0, [r3, #0]

  	while (!(PLLSTAT & PLLSTAT_LOCK));		// Espera que o PLL trave. No Skyeye não se usa
    12ce:	6828      	ldr	r0, [r5, #0]
    12d0:	4c2c      	ldr	r4, [pc, #176]	; (1384 <arm_Init+0x11c>)
    12d2:	f010 6f80 	tst.w	r0, #67108864	; 0x4000000
    12d6:	d0fa      	beq.n	12ce <arm_Init+0x66>
  	#if defined(LPC1751) || defined(LPC1752)
  	pll_Connect();							// Conecta PLL
    12d8:	6810      	ldr	r0, [r2, #0]
    12da:	f040 0002 	orr.w	r0, r0, #2
    12de:	6010      	str	r0, [r2, #0]
  	PLLFEED = 0xAA;	PLLFEED = 0x55;			// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12e0:	22aa      	movs	r2, #170	; 0xaa
    12e2:	601a      	str	r2, [r3, #0]
    12e4:	2255      	movs	r2, #85	; 0x55
    12e6:	601a      	str	r2, [r3, #0]
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
    12e8:	6823      	ldr	r3, [r4, #0]
    12ea:	019a      	lsls	r2, r3, #6
    12ec:	d5fc      	bpl.n	12e8 <arm_Init+0x80>
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
    12ee:	4a26      	ldr	r2, [pc, #152]	; (1388 <arm_Init+0x120>)
    12f0:	2300      	movs	r3, #0
    12f2:	6013      	str	r3, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    12f4:	4d25      	ldr	r5, [pc, #148]	; (138c <arm_Init+0x124>)
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12f6:	4b26      	ldr	r3, [pc, #152]	; (1390 <arm_Init+0x128>)
    12f8:	24aa      	movs	r4, #170	; 0xaa
    12fa:	2055      	movs	r0, #85	; 0x55
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    12fc:	2607      	movs	r6, #7
  	while (!(PLLSTAT & PLLSTAT_PLLC));		// Espera que o PLL se conecte ao sistema
  	#endif

  	#if defined(OSC_XTAL)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    12fe:	601c      	str	r4, [r3, #0]
    1300:	6018      	str	r0, [r3, #0]
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
    1302:	602e      	str	r6, [r5, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1304:	601c      	str	r4, [r3, #0]
    1306:	6018      	str	r0, [r3, #0]
  	pll1_ON();								// Habilita PLL
    1308:	6815      	ldr	r5, [r2, #0]
    130a:	f045 0501 	orr.w	r5, r5, #1
    130e:	6015      	str	r5, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG

  	while (!(PLL1STAT & PLL1STAT_LOCK));	// Espera que o PLL trave. No Skyeye não se usa
    1310:	4d20      	ldr	r5, [pc, #128]	; (1394 <arm_Init+0x12c>)
  	pll1_OFF(); 							// Desabilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	PLL1CFG = PLL1CFG_MSEL | PLL1CFG_PSEL;	// Ajustando o multiplicador e divisor do PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
  	pll1_ON();								// Habilita PLL
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1312:	601c      	str	r4, [r3, #0]
    1314:	6018      	str	r0, [r3, #0]

  	while (!(PLL1STAT & PLL1STAT_LOCK));	// Espera que o PLL trave. No Skyeye não se usa
    1316:	6828      	ldr	r0, [r5, #0]
    1318:	4c1e      	ldr	r4, [pc, #120]	; (1394 <arm_Init+0x12c>)
    131a:	f410 6f80 	tst.w	r0, #1024	; 0x400
    131e:	d0fa      	beq.n	1316 <arm_Init+0xae>
  	#if defined(LPC1751) || defined(LPC1752)
  	pll1_Connect();							// Conecta PLL
    1320:	6810      	ldr	r0, [r2, #0]
    1322:	f040 0002 	orr.w	r0, r0, #2
    1326:	6010      	str	r0, [r2, #0]
  	PLL1FEED = 0xAA;	PLL1FEED = 0x55;	// Sequencia para validar as mudanças nos registradores PLLCON e PLLCFG
    1328:	22aa      	movs	r2, #170	; 0xaa
    132a:	601a      	str	r2, [r3, #0]
    132c:	2255      	movs	r2, #85	; 0x55
    132e:	601a      	str	r2, [r3, #0]
	while (!(PLL1STAT & PLL1STAT_PLLC));	// Espera que o PLL se conecte ao sistema
    1330:	6823      	ldr	r3, [r4, #0]
    1332:	059b      	lsls	r3, r3, #22
    1334:	d5fc      	bpl.n	1330 <arm_Init+0xc8>
  	#endif
  	usbksel_clkDiv(USBCLKDIV);				// Aplicar divisor obter o USBCLK do PLL1_OUT
    1336:	4a18      	ldr	r2, [pc, #96]	; (1398 <arm_Init+0x130>)
    1338:	6813      	ldr	r3, [r2, #0]
    133a:	f023 030f 	bic.w	r3, r3, #15
    133e:	f043 0301 	orr.w	r3, r3, #1
    1342:	6013      	str	r3, [r2, #0]
  	#endif

  	cclksel_clkDiv(CCLKDIV);				// Aplicar divisor obter o CCLK do PLL_OUT
    1344:	680b      	ldr	r3, [r1, #0]
    1346:	f023 03ff 	bic.w	r3, r3, #255	; 0xff
    134a:	f043 0302 	orr.w	r3, r3, #2
    134e:	600b      	str	r3, [r1, #0]
		// Pclk roda 1/2 da velocidade do clock da CPU (Cclk)
	  	PCLKSEL  = 0xaaa2a2aa;
  		PCLKSEL1 = 0xa8aaa8aa;
	#elif ((CCLK / PCLK) == 4)
		// Pclk roda 1/4 da velocidade do clock da CPU (Cclk)
	  	PCLKSEL = 0x0;
    1350:	2300      	movs	r3, #0
    1352:	f8c2 30a0 	str.w	r3, [r2, #160]	; 0xa0
  		PCLKSEL1 = 0x0;
    1356:	f8c2 30a4 	str.w	r3, [r2, #164]	; 0xa4
	// O power boost (PBOOST) é ativado após o reset, permitindo trabalhar com frequencia da CPU de até
	//	seu limite máximo. Vamos deixar desse modo, mas se usar gestão de economia de energia teremos
	//	que rever isto
	#if (FLASHTIM == FLASHTIM_AUTO)
		#if (CCLK >= 100000000)
		FLASHCFG = FLASHTIM_100MHZ | 0x3a; // definir a velocidade de acesso a flash (consulte _config_cpu_.h)
    135a:	f244 023a 	movw	r2, #16442	; 0x403a
    135e:	4b0f      	ldr	r3, [pc, #60]	; (139c <arm_Init+0x134>)
    1360:	601a      	str	r2, [r3, #0]
    1362:	bd70      	pop	{r4, r5, r6, pc}
    1364:	e000ed08 	.word	0xe000ed08
    1368:	400fc0c4 	.word	0x400fc0c4
    136c:	400fc104 	.word	0x400fc104
    1370:	400fc10c 	.word	0x400fc10c
    1374:	400fc1a0 	.word	0x400fc1a0
    1378:	400fc080 	.word	0x400fc080
    137c:	400fc084 	.word	0x400fc084
    1380:	400fc08c 	.word	0x400fc08c
    1384:	400fc088 	.word	0x400fc088
    1388:	400fc0a0 	.word	0x400fc0a0
    138c:	400fc0a4 	.word	0x400fc0a4
    1390:	400fc0ac 	.word	0x400fc0ac
    1394:	400fc0a8 	.word	0x400fc0a8
    1398:	400fc108 	.word	0x400fc108
    139c:	400fc000 	.word	0x400fc000

Disassembly of section .text._start:

000013a0 <_start>:
#endif


// ESTA FUNÇÃO É CHAMADA PELO VETOR DE INTERRUPÇÃO RESET
void _start (void);
void _start (void) {
    13a0:	b508      	push	{r3, lr}
	// DESABILITA TODAS AS INTERRUPÇÕES
	irq_Disable();
    13a2:	b672      	cpsid	i
	// -------------------------------------------------------------------------------------------------------------------------
	// CONFIGURA PROCESSADOR ARM
	// 	As configurações do arm deve ser feita antes, isto porque em algumas configurações abaixo
	//	 necessitam de delays para inicializações baseadas na frequencia do processador
	// -------------------------------------------------------------------------------------------------------------------------
	arm_Init();
    13a4:	f7ff ff60 	bl	1268 <arm_Init>
    13a8:	4a0a      	ldr	r2, [pc, #40]	; (13d4 <_start+0x34>)
    13aa:	4b0b      	ldr	r3, [pc, #44]	; (13d8 <_start+0x38>)
	// ATRIBUI OS VALORES INICIAIS DAS VARIÁVEIS DA SECÇÃO .data
	// -------------------------------------------------------------------------------------------------------------------------
	#if defined(RUN_MODE1) || defined(RUN_MODE2) || defined (RUN_MODEBOOT1) || defined (RUN_MODEBOOT2)
	pSrc  = &_etext; 		// Captura o endereço final da secção .text e .rodata. Onde contém os valores da variáveis inicializadas
	pDest = &_data;			// Captura o endereço inicial da área de RAM da secção .data (variáveis inicializadas)
	while(pDest < &_edata)	// Faça até o endereço final da área de RAM da secção .data
    13ac:	490b      	ldr	r1, [pc, #44]	; (13dc <_start+0x3c>)
    13ae:	428b      	cmp	r3, r1
    13b0:	d204      	bcs.n	13bc <_start+0x1c>
		*pDest++ = *pSrc++;
    13b2:	f852 0f04 	ldr.w	r0, [r2, #4]!
    13b6:	f843 0b04 	str.w	r0, [r3], #4
    13ba:	e7f8      	b.n	13ae <_start+0xe>
    13bc:	4b08      	ldr	r3, [pc, #32]	; (13e0 <_start+0x40>)

	// -------------------------------------------------------------------------------------------------------------------------
	// LIMPA A ÁREA DE RAM DAS VARIÁVEIS NÃO INICIALIZADAS
	// -------------------------------------------------------------------------------------------------------------------------
	pDest = &_bss; 			// Captura o endereço inicial da área de RAM da secção .bss (variáveis não inicializadas)
	while(pDest < &_ebss)	// Faça até o endereço final da área de RAM da secção .bss
    13be:	4a09      	ldr	r2, [pc, #36]	; (13e4 <_start+0x44>)
		*pDest++ = 0;		// Limpa o endereço de memória
    13c0:	2100      	movs	r1, #0

	// -------------------------------------------------------------------------------------------------------------------------
	// LIMPA A ÁREA DE RAM DAS VARIÁVEIS NÃO INICIALIZADAS
	// -------------------------------------------------------------------------------------------------------------------------
	pDest = &_bss; 			// Captura o endereço inicial da área de RAM da secção .bss (variáveis não inicializadas)
	while(pDest < &_ebss)	// Faça até o endereço final da área de RAM da secção .bss
    13c2:	4293      	cmp	r3, r2
    13c4:	d202      	bcs.n	13cc <_start+0x2c>
		*pDest++ = 0;		// Limpa o endereço de memória
    13c6:	f843 1b04 	str.w	r1, [r3], #4
    13ca:	e7fa      	b.n	13c2 <_start+0x22>


	// -------------------------------------------------------------------------------------------------------------------------
	// CHAMA O PROGRAMA MAIN SEM PASSAGEM DE PARAMETROS
	// -------------------------------------------------------------------------------------------------------------------------
	main();
    13cc:	f001 f930 	bl	2630 <main>
    13d0:	e7fe      	b.n	13d0 <_start+0x30>
    13d2:	bf00      	nop
    13d4:	000055f0 	.word	0x000055f0
    13d8:	10000000 	.word	0x10000000
    13dc:	100005ac 	.word	0x100005ac
    13e0:	100005ac 	.word	0x100005ac
    13e4:	10000e5c 	.word	0x10000e5c

Disassembly of section .text.nmi_ISR:

000013e8 <nmi_ISR>:
}; /* gVectors */

/*
 * And here are the weak interrupt handlers.
 */
void nmi_ISR (void) {
    13e8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr NMI");
    13ea:	4905      	ldr	r1, [pc, #20]	; (1400 <nmi_ISR+0x18>)
    13ec:	2002      	movs	r0, #2
    13ee:	f002 fd2f 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(1);
    13f2:	4b04      	ldr	r3, [pc, #16]	; (1404 <nmi_ISR+0x1c>)
    13f4:	681a      	ldr	r2, [r3, #0]
    13f6:	b112      	cbz	r2, 13fe <nmi_ISR+0x16>
    13f8:	681b      	ldr	r3, [r3, #0]
    13fa:	2001      	movs	r0, #1
    13fc:	4798      	blx	r3
    13fe:	e7fe      	b.n	13fe <nmi_ISR+0x16>
    1400:	00004b58 	.word	0x00004b58
    1404:	100005f8 	.word	0x100005f8

Disassembly of section .text.hardFault_ISR:

00001408 <hardFault_ISR>:
	while(1);
}

void hardFault_ISR (void) {
    1408:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr hardFault"CMD_TERMINATOR);
    140a:	490d      	ldr	r1, [pc, #52]	; (1440 <hardFault_ISR+0x38>)
    140c:	2002      	movs	r0, #2
    140e:	f002 fd1f 	bl	3e50 <rprintf>
	plognp("Possiveis causas:"CMD_TERMINATOR);
    1412:	490c      	ldr	r1, [pc, #48]	; (1444 <hardFault_ISR+0x3c>)
    1414:	2002      	movs	r0, #2
    1416:	f002 fd1b 	bl	3e50 <rprintf>
	plognp("  Acesso a um hardware não ligado ou com clock desligado"CMD_TERMINATOR);
    141a:	490b      	ldr	r1, [pc, #44]	; (1448 <hardFault_ISR+0x40>)
    141c:	2002      	movs	r0, #2
    141e:	f002 fd17 	bl	3e50 <rprintf>
	plognp("  Acesso a memória inexistente"CMD_TERMINATOR);
    1422:	490a      	ldr	r1, [pc, #40]	; (144c <hardFault_ISR+0x44>)
    1424:	2002      	movs	r0, #2
    1426:	f002 fd13 	bl	3e50 <rprintf>
	plognp("  Registrador acessando pino I/O apontando para duas funções diferentes"CMD_TERMINATOR);
    142a:	4909      	ldr	r1, [pc, #36]	; (1450 <hardFault_ISR+0x48>)
    142c:	2002      	movs	r0, #2
    142e:	f002 fd0f 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(2);
    1432:	4b08      	ldr	r3, [pc, #32]	; (1454 <hardFault_ISR+0x4c>)
    1434:	681a      	ldr	r2, [r3, #0]
    1436:	b112      	cbz	r2, 143e <hardFault_ISR+0x36>
    1438:	681b      	ldr	r3, [r3, #0]
    143a:	2002      	movs	r0, #2
    143c:	4798      	blx	r3
    143e:	e7fe      	b.n	143e <hardFault_ISR+0x36>
    1440:	00004b63 	.word	0x00004b63
    1444:	00004b75 	.word	0x00004b75
    1448:	00004b88 	.word	0x00004b88
    144c:	00004bc2 	.word	0x00004bc2
    1450:	00004be2 	.word	0x00004be2
    1454:	100005f8 	.word	0x100005f8

Disassembly of section .text.memManage_ISR:

00001458 <memManage_ISR>:
	while(1);
}
void memManage_ISR (void) {
    1458:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr memManage");
    145a:	4905      	ldr	r1, [pc, #20]	; (1470 <memManage_ISR+0x18>)
    145c:	2002      	movs	r0, #2
    145e:	f002 fcf7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(3);
    1462:	4b04      	ldr	r3, [pc, #16]	; (1474 <memManage_ISR+0x1c>)
    1464:	681a      	ldr	r2, [r3, #0]
    1466:	b112      	cbz	r2, 146e <memManage_ISR+0x16>
    1468:	681b      	ldr	r3, [r3, #0]
    146a:	2003      	movs	r0, #3
    146c:	4798      	blx	r3
    146e:	e7fe      	b.n	146e <memManage_ISR+0x16>
    1470:	00004c2b 	.word	0x00004c2b
    1474:	100005f8 	.word	0x100005f8

Disassembly of section .text.busFault_ISR:

00001478 <busFault_ISR>:
	while(1);
}
void busFault_ISR (void) {
    1478:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr busFault");
    147a:	4905      	ldr	r1, [pc, #20]	; (1490 <busFault_ISR+0x18>)
    147c:	2002      	movs	r0, #2
    147e:	f002 fce7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(4);
    1482:	4b04      	ldr	r3, [pc, #16]	; (1494 <busFault_ISR+0x1c>)
    1484:	681a      	ldr	r2, [r3, #0]
    1486:	b112      	cbz	r2, 148e <busFault_ISR+0x16>
    1488:	681b      	ldr	r3, [r3, #0]
    148a:	2004      	movs	r0, #4
    148c:	4798      	blx	r3
    148e:	e7fe      	b.n	148e <busFault_ISR+0x16>
    1490:	00004c3c 	.word	0x00004c3c
    1494:	100005f8 	.word	0x100005f8

Disassembly of section .text.usageFault_ISR:

00001498 <usageFault_ISR>:
	while(1);
}
void usageFault_ISR (void) {
    1498:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr usageFault_ISR");
    149a:	4905      	ldr	r1, [pc, #20]	; (14b0 <usageFault_ISR+0x18>)
    149c:	2002      	movs	r0, #2
    149e:	f002 fcd7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(5);
    14a2:	4b04      	ldr	r3, [pc, #16]	; (14b4 <usageFault_ISR+0x1c>)
    14a4:	681a      	ldr	r2, [r3, #0]
    14a6:	b112      	cbz	r2, 14ae <usageFault_ISR+0x16>
    14a8:	681b      	ldr	r3, [r3, #0]
    14aa:	2005      	movs	r0, #5
    14ac:	4798      	blx	r3
    14ae:	e7fe      	b.n	14ae <usageFault_ISR+0x16>
    14b0:	00004c4c 	.word	0x00004c4c
    14b4:	100005f8 	.word	0x100005f8

Disassembly of section .text.svc_ISR:

000014b8 <svc_ISR>:
	while(1);
}
void svc_ISR (void) {
    14b8:	b508      	push	{r3, lr}
#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr svc");
    14ba:	4905      	ldr	r1, [pc, #20]	; (14d0 <svc_ISR+0x18>)
    14bc:	2002      	movs	r0, #2
    14be:	f002 fcc7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(6);
    14c2:	4b04      	ldr	r3, [pc, #16]	; (14d4 <svc_ISR+0x1c>)
    14c4:	681a      	ldr	r2, [r3, #0]
    14c6:	b112      	cbz	r2, 14ce <svc_ISR+0x16>
    14c8:	681b      	ldr	r3, [r3, #0]
    14ca:	2006      	movs	r0, #6
    14cc:	4798      	blx	r3
    14ce:	e7fe      	b.n	14ce <svc_ISR+0x16>
    14d0:	00004c62 	.word	0x00004c62
    14d4:	100005f8 	.word	0x100005f8

Disassembly of section .text.debugMon_ISR:

000014d8 <debugMon_ISR>:
	while(1);
}
void debugMon_ISR (void) {
    14d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr debugMon");
    14da:	4905      	ldr	r1, [pc, #20]	; (14f0 <debugMon_ISR+0x18>)
    14dc:	2002      	movs	r0, #2
    14de:	f002 fcb7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(7);
    14e2:	4b04      	ldr	r3, [pc, #16]	; (14f4 <debugMon_ISR+0x1c>)
    14e4:	681a      	ldr	r2, [r3, #0]
    14e6:	b112      	cbz	r2, 14ee <debugMon_ISR+0x16>
    14e8:	681b      	ldr	r3, [r3, #0]
    14ea:	2007      	movs	r0, #7
    14ec:	4798      	blx	r3
    14ee:	e7fe      	b.n	14ee <debugMon_ISR+0x16>
    14f0:	00004c6d 	.word	0x00004c6d
    14f4:	100005f8 	.word	0x100005f8

Disassembly of section .text.pendSV_ISR:

000014f8 <pendSV_ISR>:
	while(1);
}
void pendSV_ISR (void) {
    14f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pendSV");
    14fa:	4905      	ldr	r1, [pc, #20]	; (1510 <pendSV_ISR+0x18>)
    14fc:	2002      	movs	r0, #2
    14fe:	f002 fca7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(8);
    1502:	4b04      	ldr	r3, [pc, #16]	; (1514 <pendSV_ISR+0x1c>)
    1504:	681a      	ldr	r2, [r3, #0]
    1506:	b112      	cbz	r2, 150e <pendSV_ISR+0x16>
    1508:	681b      	ldr	r3, [r3, #0]
    150a:	2008      	movs	r0, #8
    150c:	4798      	blx	r3
    150e:	e7fe      	b.n	150e <pendSV_ISR+0x16>
    1510:	00004c7d 	.word	0x00004c7d
    1514:	100005f8 	.word	0x100005f8

Disassembly of section .text.wdt_ISR:

00001518 <wdt_ISR>:
	plognp("vicErr sysTick");
	#endif
	if (vicerr_Functions) vicerr_Functions(9);
	while(1);
}
void wdt_ISR (void) {
    1518:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr wdt");
    151a:	4905      	ldr	r1, [pc, #20]	; (1530 <wdt_ISR+0x18>)
    151c:	2002      	movs	r0, #2
    151e:	f002 fc97 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(10);
    1522:	4b04      	ldr	r3, [pc, #16]	; (1534 <wdt_ISR+0x1c>)
    1524:	681a      	ldr	r2, [r3, #0]
    1526:	b112      	cbz	r2, 152e <wdt_ISR+0x16>
    1528:	681b      	ldr	r3, [r3, #0]
    152a:	200a      	movs	r0, #10
    152c:	4798      	blx	r3
    152e:	e7fe      	b.n	152e <wdt_ISR+0x16>
    1530:	00004c9a 	.word	0x00004c9a
    1534:	100005f8 	.word	0x100005f8

Disassembly of section .text.timer0_ISR:

00001538 <timer0_ISR>:
	while(1);
}
void timer0_ISR (void) {
    1538:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer0");
    153a:	4905      	ldr	r1, [pc, #20]	; (1550 <timer0_ISR+0x18>)
    153c:	2002      	movs	r0, #2
    153e:	f002 fc87 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(11);
    1542:	4b04      	ldr	r3, [pc, #16]	; (1554 <timer0_ISR+0x1c>)
    1544:	681a      	ldr	r2, [r3, #0]
    1546:	b112      	cbz	r2, 154e <timer0_ISR+0x16>
    1548:	681b      	ldr	r3, [r3, #0]
    154a:	200b      	movs	r0, #11
    154c:	4798      	blx	r3
    154e:	e7fe      	b.n	154e <timer0_ISR+0x16>
    1550:	00004ca5 	.word	0x00004ca5
    1554:	100005f8 	.word	0x100005f8

Disassembly of section .text.timer1_ISR:

00001558 <timer1_ISR>:
	while(1);
}
void timer1_ISR (void) {
    1558:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer1");
    155a:	4905      	ldr	r1, [pc, #20]	; (1570 <timer1_ISR+0x18>)
    155c:	2002      	movs	r0, #2
    155e:	f002 fc77 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(12);
    1562:	4b04      	ldr	r3, [pc, #16]	; (1574 <timer1_ISR+0x1c>)
    1564:	681a      	ldr	r2, [r3, #0]
    1566:	b112      	cbz	r2, 156e <timer1_ISR+0x16>
    1568:	681b      	ldr	r3, [r3, #0]
    156a:	200c      	movs	r0, #12
    156c:	4798      	blx	r3
    156e:	e7fe      	b.n	156e <timer1_ISR+0x16>
    1570:	00004cb3 	.word	0x00004cb3
    1574:	100005f8 	.word	0x100005f8

Disassembly of section .text.timer2_ISR:

00001578 <timer2_ISR>:
	while(1);
}
void timer2_ISR (void) {
    1578:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer2");
    157a:	4905      	ldr	r1, [pc, #20]	; (1590 <timer2_ISR+0x18>)
    157c:	2002      	movs	r0, #2
    157e:	f002 fc67 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(13);
    1582:	4b04      	ldr	r3, [pc, #16]	; (1594 <timer2_ISR+0x1c>)
    1584:	681a      	ldr	r2, [r3, #0]
    1586:	b112      	cbz	r2, 158e <timer2_ISR+0x16>
    1588:	681b      	ldr	r3, [r3, #0]
    158a:	200d      	movs	r0, #13
    158c:	4798      	blx	r3
    158e:	e7fe      	b.n	158e <timer2_ISR+0x16>
    1590:	00004cc1 	.word	0x00004cc1
    1594:	100005f8 	.word	0x100005f8

Disassembly of section .text.timer3_ISR:

00001598 <timer3_ISR>:
	while(1);
}
void timer3_ISR (void) {
    1598:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr timer3");
    159a:	4905      	ldr	r1, [pc, #20]	; (15b0 <timer3_ISR+0x18>)
    159c:	2002      	movs	r0, #2
    159e:	f002 fc57 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(14);
    15a2:	4b04      	ldr	r3, [pc, #16]	; (15b4 <timer3_ISR+0x1c>)
    15a4:	681a      	ldr	r2, [r3, #0]
    15a6:	b112      	cbz	r2, 15ae <timer3_ISR+0x16>
    15a8:	681b      	ldr	r3, [r3, #0]
    15aa:	200e      	movs	r0, #14
    15ac:	4798      	blx	r3
    15ae:	e7fe      	b.n	15ae <timer3_ISR+0x16>
    15b0:	00004ccf 	.word	0x00004ccf
    15b4:	100005f8 	.word	0x100005f8

Disassembly of section .text.uart2_ISR:

000015b8 <uart2_ISR>:
	plognp("vicErr uart1");
	#endif
	if (vicerr_Functions) vicerr_Functions(16);
	while(1);
}
void uart2_ISR (void) {
    15b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart2");
    15ba:	4905      	ldr	r1, [pc, #20]	; (15d0 <uart2_ISR+0x18>)
    15bc:	2002      	movs	r0, #2
    15be:	f002 fc47 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(17);
    15c2:	4b04      	ldr	r3, [pc, #16]	; (15d4 <uart2_ISR+0x1c>)
    15c4:	681a      	ldr	r2, [r3, #0]
    15c6:	b112      	cbz	r2, 15ce <uart2_ISR+0x16>
    15c8:	681b      	ldr	r3, [r3, #0]
    15ca:	2011      	movs	r0, #17
    15cc:	4798      	blx	r3
    15ce:	e7fe      	b.n	15ce <uart2_ISR+0x16>
    15d0:	00004cf7 	.word	0x00004cf7
    15d4:	100005f8 	.word	0x100005f8

Disassembly of section .text.pwm_ISR:

000015d8 <pwm_ISR>:
	plognp("vicErr uart3");
	#endif
	if (vicerr_Functions) vicerr_Functions(18);
	while(1);
}
void pwm_ISR (void) {
    15d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pwm");
    15da:	4905      	ldr	r1, [pc, #20]	; (15f0 <pwm_ISR+0x18>)
    15dc:	2002      	movs	r0, #2
    15de:	f002 fc37 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(19);
    15e2:	4b04      	ldr	r3, [pc, #16]	; (15f4 <pwm_ISR+0x1c>)
    15e4:	681a      	ldr	r2, [r3, #0]
    15e6:	b112      	cbz	r2, 15ee <pwm_ISR+0x16>
    15e8:	681b      	ldr	r3, [r3, #0]
    15ea:	2013      	movs	r0, #19
    15ec:	4798      	blx	r3
    15ee:	e7fe      	b.n	15ee <pwm_ISR+0x16>
    15f0:	00004d11 	.word	0x00004d11
    15f4:	100005f8 	.word	0x100005f8

Disassembly of section .text.i2c0_ISR:

000015f8 <i2c0_ISR>:
	while(1);
}
void i2c0_ISR (void) {
    15f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c0");
    15fa:	4905      	ldr	r1, [pc, #20]	; (1610 <i2c0_ISR+0x18>)
    15fc:	2002      	movs	r0, #2
    15fe:	f002 fc27 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(20);
    1602:	4b04      	ldr	r3, [pc, #16]	; (1614 <i2c0_ISR+0x1c>)
    1604:	681a      	ldr	r2, [r3, #0]
    1606:	b112      	cbz	r2, 160e <i2c0_ISR+0x16>
    1608:	681b      	ldr	r3, [r3, #0]
    160a:	2014      	movs	r0, #20
    160c:	4798      	blx	r3
    160e:	e7fe      	b.n	160e <i2c0_ISR+0x16>
    1610:	00004d1c 	.word	0x00004d1c
    1614:	100005f8 	.word	0x100005f8

Disassembly of section .text.i2c1_ISR:

00001618 <i2c1_ISR>:
	while(1);
}
void i2c1_ISR (void) {
    1618:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c1");
    161a:	4905      	ldr	r1, [pc, #20]	; (1630 <i2c1_ISR+0x18>)
    161c:	2002      	movs	r0, #2
    161e:	f002 fc17 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(21);
    1622:	4b04      	ldr	r3, [pc, #16]	; (1634 <i2c1_ISR+0x1c>)
    1624:	681a      	ldr	r2, [r3, #0]
    1626:	b112      	cbz	r2, 162e <i2c1_ISR+0x16>
    1628:	681b      	ldr	r3, [r3, #0]
    162a:	2015      	movs	r0, #21
    162c:	4798      	blx	r3
    162e:	e7fe      	b.n	162e <i2c1_ISR+0x16>
    1630:	00004d28 	.word	0x00004d28
    1634:	100005f8 	.word	0x100005f8

Disassembly of section .text.i2c2_ISR:

00001638 <i2c2_ISR>:
	while(1);
}
void i2c2_ISR (void) {
    1638:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2c2");
    163a:	4905      	ldr	r1, [pc, #20]	; (1650 <i2c2_ISR+0x18>)
    163c:	2002      	movs	r0, #2
    163e:	f002 fc07 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(22);
    1642:	4b04      	ldr	r3, [pc, #16]	; (1654 <i2c2_ISR+0x1c>)
    1644:	681a      	ldr	r2, [r3, #0]
    1646:	b112      	cbz	r2, 164e <i2c2_ISR+0x16>
    1648:	681b      	ldr	r3, [r3, #0]
    164a:	2016      	movs	r0, #22
    164c:	4798      	blx	r3
    164e:	e7fe      	b.n	164e <i2c2_ISR+0x16>
    1650:	00004d34 	.word	0x00004d34
    1654:	100005f8 	.word	0x100005f8

Disassembly of section .text.spi_ISR:

00001658 <spi_ISR>:
	while(1);
}
void spi_ISR (void) {
    1658:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spi");
    165a:	4905      	ldr	r1, [pc, #20]	; (1670 <spi_ISR+0x18>)
    165c:	2002      	movs	r0, #2
    165e:	f002 fbf7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(23);
    1662:	4b04      	ldr	r3, [pc, #16]	; (1674 <spi_ISR+0x1c>)
    1664:	681a      	ldr	r2, [r3, #0]
    1666:	b112      	cbz	r2, 166e <spi_ISR+0x16>
    1668:	681b      	ldr	r3, [r3, #0]
    166a:	2017      	movs	r0, #23
    166c:	4798      	blx	r3
    166e:	e7fe      	b.n	166e <spi_ISR+0x16>
    1670:	00004d40 	.word	0x00004d40
    1674:	100005f8 	.word	0x100005f8

Disassembly of section .text.ssp0_ISR:

00001678 <ssp0_ISR>:
	while(1);
}
void ssp0_ISR (void) {
    1678:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spp0");
    167a:	4905      	ldr	r1, [pc, #20]	; (1690 <ssp0_ISR+0x18>)
    167c:	2002      	movs	r0, #2
    167e:	f002 fbe7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(24);
    1682:	4b04      	ldr	r3, [pc, #16]	; (1694 <ssp0_ISR+0x1c>)
    1684:	681a      	ldr	r2, [r3, #0]
    1686:	b112      	cbz	r2, 168e <ssp0_ISR+0x16>
    1688:	681b      	ldr	r3, [r3, #0]
    168a:	2018      	movs	r0, #24
    168c:	4798      	blx	r3
    168e:	e7fe      	b.n	168e <ssp0_ISR+0x16>
    1690:	00004d4b 	.word	0x00004d4b
    1694:	100005f8 	.word	0x100005f8

Disassembly of section .text.ssp1_ISR:

00001698 <ssp1_ISR>:
	while(1);
}
void ssp1_ISR (void) {
    1698:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr spp1");
    169a:	4905      	ldr	r1, [pc, #20]	; (16b0 <ssp1_ISR+0x18>)
    169c:	2002      	movs	r0, #2
    169e:	f002 fbd7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(25);
    16a2:	4b04      	ldr	r3, [pc, #16]	; (16b4 <ssp1_ISR+0x1c>)
    16a4:	681a      	ldr	r2, [r3, #0]
    16a6:	b112      	cbz	r2, 16ae <ssp1_ISR+0x16>
    16a8:	681b      	ldr	r3, [r3, #0]
    16aa:	2019      	movs	r0, #25
    16ac:	4798      	blx	r3
    16ae:	e7fe      	b.n	16ae <ssp1_ISR+0x16>
    16b0:	00004d57 	.word	0x00004d57
    16b4:	100005f8 	.word	0x100005f8

Disassembly of section .text.pll0_ISR:

000016b8 <pll0_ISR>:
	while(1);
}
void pll0_ISR (void) {
    16b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pll0");
    16ba:	4905      	ldr	r1, [pc, #20]	; (16d0 <pll0_ISR+0x18>)
    16bc:	2002      	movs	r0, #2
    16be:	f002 fbc7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(26);
    16c2:	4b04      	ldr	r3, [pc, #16]	; (16d4 <pll0_ISR+0x1c>)
    16c4:	681a      	ldr	r2, [r3, #0]
    16c6:	b112      	cbz	r2, 16ce <pll0_ISR+0x16>
    16c8:	681b      	ldr	r3, [r3, #0]
    16ca:	201a      	movs	r0, #26
    16cc:	4798      	blx	r3
    16ce:	e7fe      	b.n	16ce <pll0_ISR+0x16>
    16d0:	00004d63 	.word	0x00004d63
    16d4:	100005f8 	.word	0x100005f8

Disassembly of section .text.rtc_ISR:

000016d8 <rtc_ISR>:
	while(1);
}
void rtc_ISR (void) {
    16d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr ");
    16da:	4905      	ldr	r1, [pc, #20]	; (16f0 <rtc_ISR+0x18>)
    16dc:	2002      	movs	r0, #2
    16de:	f002 fbb7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(27);
    16e2:	4b04      	ldr	r3, [pc, #16]	; (16f4 <rtc_ISR+0x1c>)
    16e4:	681a      	ldr	r2, [r3, #0]
    16e6:	b112      	cbz	r2, 16ee <rtc_ISR+0x16>
    16e8:	681b      	ldr	r3, [r3, #0]
    16ea:	201b      	movs	r0, #27
    16ec:	4798      	blx	r3
    16ee:	e7fe      	b.n	16ee <rtc_ISR+0x16>
    16f0:	00004d6f 	.word	0x00004d6f
    16f4:	100005f8 	.word	0x100005f8

Disassembly of section .text.eint0_ISR:

000016f8 <eint0_ISR>:
	while(1);
}
void eint0_ISR (void) {
    16f8:	b508      	push	{r3, lr}
#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint0");
    16fa:	4905      	ldr	r1, [pc, #20]	; (1710 <eint0_ISR+0x18>)
    16fc:	2002      	movs	r0, #2
    16fe:	f002 fba7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(28);
    1702:	4b04      	ldr	r3, [pc, #16]	; (1714 <eint0_ISR+0x1c>)
    1704:	681a      	ldr	r2, [r3, #0]
    1706:	b112      	cbz	r2, 170e <eint0_ISR+0x16>
    1708:	681b      	ldr	r3, [r3, #0]
    170a:	201c      	movs	r0, #28
    170c:	4798      	blx	r3
    170e:	e7fe      	b.n	170e <eint0_ISR+0x16>
    1710:	00004d77 	.word	0x00004d77
    1714:	100005f8 	.word	0x100005f8

Disassembly of section .text.eint1_ISR:

00001718 <eint1_ISR>:
	while(1);
}
void eint1_ISR (void) {
    1718:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint1");
    171a:	4905      	ldr	r1, [pc, #20]	; (1730 <eint1_ISR+0x18>)
    171c:	2002      	movs	r0, #2
    171e:	f002 fb97 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(29);
    1722:	4b04      	ldr	r3, [pc, #16]	; (1734 <eint1_ISR+0x1c>)
    1724:	681a      	ldr	r2, [r3, #0]
    1726:	b112      	cbz	r2, 172e <eint1_ISR+0x16>
    1728:	681b      	ldr	r3, [r3, #0]
    172a:	201d      	movs	r0, #29
    172c:	4798      	blx	r3
    172e:	e7fe      	b.n	172e <eint1_ISR+0x16>
    1730:	00004d84 	.word	0x00004d84
    1734:	100005f8 	.word	0x100005f8

Disassembly of section .text.eint2_ISR:

00001738 <eint2_ISR>:
	while(1);
}
void eint2_ISR (void) {
    1738:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint2");
    173a:	4905      	ldr	r1, [pc, #20]	; (1750 <eint2_ISR+0x18>)
    173c:	2002      	movs	r0, #2
    173e:	f002 fb87 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(30);
    1742:	4b04      	ldr	r3, [pc, #16]	; (1754 <eint2_ISR+0x1c>)
    1744:	681a      	ldr	r2, [r3, #0]
    1746:	b112      	cbz	r2, 174e <eint2_ISR+0x16>
    1748:	681b      	ldr	r3, [r3, #0]
    174a:	201e      	movs	r0, #30
    174c:	4798      	blx	r3
    174e:	e7fe      	b.n	174e <eint2_ISR+0x16>
    1750:	00004d91 	.word	0x00004d91
    1754:	100005f8 	.word	0x100005f8

Disassembly of section .text.eint3_ISR:

00001758 <eint3_ISR>:
	while(1);
}
void eint3_ISR (void) {
    1758:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eint3");
    175a:	4905      	ldr	r1, [pc, #20]	; (1770 <eint3_ISR+0x18>)
    175c:	2002      	movs	r0, #2
    175e:	f002 fb77 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(31);
    1762:	4b04      	ldr	r3, [pc, #16]	; (1774 <eint3_ISR+0x1c>)
    1764:	681a      	ldr	r2, [r3, #0]
    1766:	b112      	cbz	r2, 176e <eint3_ISR+0x16>
    1768:	681b      	ldr	r3, [r3, #0]
    176a:	201f      	movs	r0, #31
    176c:	4798      	blx	r3
    176e:	e7fe      	b.n	176e <eint3_ISR+0x16>
    1770:	00004d9e 	.word	0x00004d9e
    1774:	100005f8 	.word	0x100005f8

Disassembly of section .text.adc_ISR:

00001778 <adc_ISR>:
	while(1);
}
void adc_ISR (void) {
    1778:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr adc");
    177a:	4905      	ldr	r1, [pc, #20]	; (1790 <adc_ISR+0x18>)
    177c:	2002      	movs	r0, #2
    177e:	f002 fb67 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(32);
    1782:	4b04      	ldr	r3, [pc, #16]	; (1794 <adc_ISR+0x1c>)
    1784:	681a      	ldr	r2, [r3, #0]
    1786:	b112      	cbz	r2, 178e <adc_ISR+0x16>
    1788:	681b      	ldr	r3, [r3, #0]
    178a:	2020      	movs	r0, #32
    178c:	4798      	blx	r3
    178e:	e7fe      	b.n	178e <adc_ISR+0x16>
    1790:	00004dab 	.word	0x00004dab
    1794:	100005f8 	.word	0x100005f8

Disassembly of section .text.bod_ISR:

00001798 <bod_ISR>:
	while(1);
}
void bod_ISR (void) {
    1798:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr bod");
    179a:	4905      	ldr	r1, [pc, #20]	; (17b0 <bod_ISR+0x18>)
    179c:	2002      	movs	r0, #2
    179e:	f002 fb57 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(33);
    17a2:	4b04      	ldr	r3, [pc, #16]	; (17b4 <bod_ISR+0x1c>)
    17a4:	681a      	ldr	r2, [r3, #0]
    17a6:	b112      	cbz	r2, 17ae <bod_ISR+0x16>
    17a8:	681b      	ldr	r3, [r3, #0]
    17aa:	2021      	movs	r0, #33	; 0x21
    17ac:	4798      	blx	r3
    17ae:	e7fe      	b.n	17ae <bod_ISR+0x16>
    17b0:	00004db6 	.word	0x00004db6
    17b4:	100005f8 	.word	0x100005f8

Disassembly of section .text.usbHost_ISR:

000017b8 <usbHost_ISR>:
	while(1);
}
void usbHost_ISR (void) {
    17b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr usb");
    17ba:	4905      	ldr	r1, [pc, #20]	; (17d0 <usbHost_ISR+0x18>)
    17bc:	2002      	movs	r0, #2
    17be:	f002 fb47 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(34);
    17c2:	4b04      	ldr	r3, [pc, #16]	; (17d4 <usbHost_ISR+0x1c>)
    17c4:	681a      	ldr	r2, [r3, #0]
    17c6:	b112      	cbz	r2, 17ce <usbHost_ISR+0x16>
    17c8:	681b      	ldr	r3, [r3, #0]
    17ca:	2022      	movs	r0, #34	; 0x22
    17cc:	4798      	blx	r3
    17ce:	e7fe      	b.n	17ce <usbHost_ISR+0x16>
    17d0:	00004dc1 	.word	0x00004dc1
    17d4:	100005f8 	.word	0x100005f8

Disassembly of section .text.can_ISR:

000017d8 <can_ISR>:
	while(1);
}
void can_ISR (void) {
    17d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr can");
    17da:	4905      	ldr	r1, [pc, #20]	; (17f0 <can_ISR+0x18>)
    17dc:	2002      	movs	r0, #2
    17de:	f002 fb37 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(35);
    17e2:	4b04      	ldr	r3, [pc, #16]	; (17f4 <can_ISR+0x1c>)
    17e4:	681a      	ldr	r2, [r3, #0]
    17e6:	b112      	cbz	r2, 17ee <can_ISR+0x16>
    17e8:	681b      	ldr	r3, [r3, #0]
    17ea:	2023      	movs	r0, #35	; 0x23
    17ec:	4798      	blx	r3
    17ee:	e7fe      	b.n	17ee <can_ISR+0x16>
    17f0:	00004dcc 	.word	0x00004dcc
    17f4:	100005f8 	.word	0x100005f8

Disassembly of section .text.dma_ISR:

000017f8 <dma_ISR>:
	while(1);
}
void dma_ISR (void) {
    17f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr dma");
    17fa:	4905      	ldr	r1, [pc, #20]	; (1810 <dma_ISR+0x18>)
    17fc:	2002      	movs	r0, #2
    17fe:	f002 fb27 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(36);
    1802:	4b04      	ldr	r3, [pc, #16]	; (1814 <dma_ISR+0x1c>)
    1804:	681a      	ldr	r2, [r3, #0]
    1806:	b112      	cbz	r2, 180e <dma_ISR+0x16>
    1808:	681b      	ldr	r3, [r3, #0]
    180a:	2024      	movs	r0, #36	; 0x24
    180c:	4798      	blx	r3
    180e:	e7fe      	b.n	180e <dma_ISR+0x16>
    1810:	00004dd7 	.word	0x00004dd7
    1814:	100005f8 	.word	0x100005f8

Disassembly of section .text.i2s_ISR:

00001818 <i2s_ISR>:
	while(1);
}
void i2s_ISR (void) {
    1818:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr i2s");
    181a:	4905      	ldr	r1, [pc, #20]	; (1830 <i2s_ISR+0x18>)
    181c:	2002      	movs	r0, #2
    181e:	f002 fb17 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(37);
    1822:	4b04      	ldr	r3, [pc, #16]	; (1834 <i2s_ISR+0x1c>)
    1824:	681a      	ldr	r2, [r3, #0]
    1826:	b112      	cbz	r2, 182e <i2s_ISR+0x16>
    1828:	681b      	ldr	r3, [r3, #0]
    182a:	2025      	movs	r0, #37	; 0x25
    182c:	4798      	blx	r3
    182e:	e7fe      	b.n	182e <i2s_ISR+0x16>
    1830:	00004de2 	.word	0x00004de2
    1834:	100005f8 	.word	0x100005f8

Disassembly of section .text.enet_ISR:

00001838 <enet_ISR>:
	while(1);
}
void enet_ISR (void) {
    1838:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr enet");
    183a:	4905      	ldr	r1, [pc, #20]	; (1850 <enet_ISR+0x18>)
    183c:	2002      	movs	r0, #2
    183e:	f002 fb07 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(38);
    1842:	4b04      	ldr	r3, [pc, #16]	; (1854 <enet_ISR+0x1c>)
    1844:	681a      	ldr	r2, [r3, #0]
    1846:	b112      	cbz	r2, 184e <enet_ISR+0x16>
    1848:	681b      	ldr	r3, [r3, #0]
    184a:	2026      	movs	r0, #38	; 0x26
    184c:	4798      	blx	r3
    184e:	e7fe      	b.n	184e <enet_ISR+0x16>
    1850:	00004ded 	.word	0x00004ded
    1854:	100005f8 	.word	0x100005f8

Disassembly of section .text.rit_ISR:

00001858 <rit_ISR>:
	while(1);
}
void rit_ISR (void) {
    1858:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr rit");
    185a:	4905      	ldr	r1, [pc, #20]	; (1870 <rit_ISR+0x18>)
    185c:	2002      	movs	r0, #2
    185e:	f002 faf7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(39);
    1862:	4b04      	ldr	r3, [pc, #16]	; (1874 <rit_ISR+0x1c>)
    1864:	681a      	ldr	r2, [r3, #0]
    1866:	b112      	cbz	r2, 186e <rit_ISR+0x16>
    1868:	681b      	ldr	r3, [r3, #0]
    186a:	2027      	movs	r0, #39	; 0x27
    186c:	4798      	blx	r3
    186e:	e7fe      	b.n	186e <rit_ISR+0x16>
    1870:	00004df9 	.word	0x00004df9
    1874:	100005f8 	.word	0x100005f8

Disassembly of section .text.mcpwm_ISR:

00001878 <mcpwm_ISR>:
	while(1);
}
void mcpwm_ISR (void) {
    1878:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr mcpwm");
    187a:	4905      	ldr	r1, [pc, #20]	; (1890 <mcpwm_ISR+0x18>)
    187c:	2002      	movs	r0, #2
    187e:	f002 fae7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(40);
    1882:	4b04      	ldr	r3, [pc, #16]	; (1894 <mcpwm_ISR+0x1c>)
    1884:	681a      	ldr	r2, [r3, #0]
    1886:	b112      	cbz	r2, 188e <mcpwm_ISR+0x16>
    1888:	681b      	ldr	r3, [r3, #0]
    188a:	2028      	movs	r0, #40	; 0x28
    188c:	4798      	blx	r3
    188e:	e7fe      	b.n	188e <mcpwm_ISR+0x16>
    1890:	00004e04 	.word	0x00004e04
    1894:	100005f8 	.word	0x100005f8

Disassembly of section .text.qei_ISR:

00001898 <qei_ISR>:
	while(1);
}
void qei_ISR (void) {
    1898:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr qei");
    189a:	4905      	ldr	r1, [pc, #20]	; (18b0 <qei_ISR+0x18>)
    189c:	2002      	movs	r0, #2
    189e:	f002 fad7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(41);
    18a2:	4b04      	ldr	r3, [pc, #16]	; (18b4 <qei_ISR+0x1c>)
    18a4:	681a      	ldr	r2, [r3, #0]
    18a6:	b112      	cbz	r2, 18ae <qei_ISR+0x16>
    18a8:	681b      	ldr	r3, [r3, #0]
    18aa:	2029      	movs	r0, #41	; 0x29
    18ac:	4798      	blx	r3
    18ae:	e7fe      	b.n	18ae <qei_ISR+0x16>
    18b0:	00004e11 	.word	0x00004e11
    18b4:	100005f8 	.word	0x100005f8

Disassembly of section .text.pll1_ISR:

000018b8 <pll1_ISR>:
	while(1);
}

void pll1_ISR (void) {
    18b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pll1");
    18ba:	4905      	ldr	r1, [pc, #20]	; (18d0 <pll1_ISR+0x18>)
    18bc:	2002      	movs	r0, #2
    18be:	f002 fac7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(42);
    18c2:	4b04      	ldr	r3, [pc, #16]	; (18d4 <pll1_ISR+0x1c>)
    18c4:	681a      	ldr	r2, [r3, #0]
    18c6:	b112      	cbz	r2, 18ce <pll1_ISR+0x16>
    18c8:	681b      	ldr	r3, [r3, #0]
    18ca:	202a      	movs	r0, #42	; 0x2a
    18cc:	4798      	blx	r3
    18ce:	e7fe      	b.n	18ce <pll1_ISR+0x16>
    18d0:	00004e1c 	.word	0x00004e1c
    18d4:	100005f8 	.word	0x100005f8

Disassembly of section .text.usbAct_ISR:

000018d8 <usbAct_ISR>:
	while(1);
}

void usbAct_ISR (void) {
    18d8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr USB ACT");
    18da:	4905      	ldr	r1, [pc, #20]	; (18f0 <usbAct_ISR+0x18>)
    18dc:	2002      	movs	r0, #2
    18de:	f002 fab7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(43);
    18e2:	4b04      	ldr	r3, [pc, #16]	; (18f4 <usbAct_ISR+0x1c>)
    18e4:	681a      	ldr	r2, [r3, #0]
    18e6:	b112      	cbz	r2, 18ee <usbAct_ISR+0x16>
    18e8:	681b      	ldr	r3, [r3, #0]
    18ea:	202b      	movs	r0, #43	; 0x2b
    18ec:	4798      	blx	r3
    18ee:	e7fe      	b.n	18ee <usbAct_ISR+0x16>
    18f0:	00004e28 	.word	0x00004e28
    18f4:	100005f8 	.word	0x100005f8

Disassembly of section .text.canAct_ISR:

000018f8 <canAct_ISR>:
	while(1);
}
void canAct_ISR (void) {
    18f8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr CAN ACT");
    18fa:	4905      	ldr	r1, [pc, #20]	; (1910 <canAct_ISR+0x18>)
    18fc:	2002      	movs	r0, #2
    18fe:	f002 faa7 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(44);
    1902:	4b04      	ldr	r3, [pc, #16]	; (1914 <canAct_ISR+0x1c>)
    1904:	681a      	ldr	r2, [r3, #0]
    1906:	b112      	cbz	r2, 190e <canAct_ISR+0x16>
    1908:	681b      	ldr	r3, [r3, #0]
    190a:	202c      	movs	r0, #44	; 0x2c
    190c:	4798      	blx	r3
    190e:	e7fe      	b.n	190e <canAct_ISR+0x16>
    1910:	00004e37 	.word	0x00004e37
    1914:	100005f8 	.word	0x100005f8

Disassembly of section .text.uart4_ISR:

00001918 <uart4_ISR>:
	while(1);
}
void uart4_ISR (void) {
    1918:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr uart4");
    191a:	4905      	ldr	r1, [pc, #20]	; (1930 <uart4_ISR+0x18>)
    191c:	2002      	movs	r0, #2
    191e:	f002 fa97 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(45);
    1922:	4b04      	ldr	r3, [pc, #16]	; (1934 <uart4_ISR+0x1c>)
    1924:	681a      	ldr	r2, [r3, #0]
    1926:	b112      	cbz	r2, 192e <uart4_ISR+0x16>
    1928:	681b      	ldr	r3, [r3, #0]
    192a:	202d      	movs	r0, #45	; 0x2d
    192c:	4798      	blx	r3
    192e:	e7fe      	b.n	192e <uart4_ISR+0x16>
    1930:	00004e46 	.word	0x00004e46
    1934:	100005f8 	.word	0x100005f8

Disassembly of section .text.ssp2_ISR:

00001938 <ssp2_ISR>:
	while(1);
}
void ssp2_ISR (void) {
    1938:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr ssp2");
    193a:	4905      	ldr	r1, [pc, #20]	; (1950 <ssp2_ISR+0x18>)
    193c:	2002      	movs	r0, #2
    193e:	f002 fa87 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(46);
    1942:	4b04      	ldr	r3, [pc, #16]	; (1954 <ssp2_ISR+0x1c>)
    1944:	681a      	ldr	r2, [r3, #0]
    1946:	b112      	cbz	r2, 194e <ssp2_ISR+0x16>
    1948:	681b      	ldr	r3, [r3, #0]
    194a:	202e      	movs	r0, #46	; 0x2e
    194c:	4798      	blx	r3
    194e:	e7fe      	b.n	194e <ssp2_ISR+0x16>
    1950:	00004e53 	.word	0x00004e53
    1954:	100005f8 	.word	0x100005f8

Disassembly of section .text.lcd_ISR:

00001958 <lcd_ISR>:
	while(1);
}
void lcd_ISR (void) {
    1958:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr lcd");
    195a:	4905      	ldr	r1, [pc, #20]	; (1970 <lcd_ISR+0x18>)
    195c:	2002      	movs	r0, #2
    195e:	f002 fa77 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(47);
    1962:	4b04      	ldr	r3, [pc, #16]	; (1974 <lcd_ISR+0x1c>)
    1964:	681a      	ldr	r2, [r3, #0]
    1966:	b112      	cbz	r2, 196e <lcd_ISR+0x16>
    1968:	681b      	ldr	r3, [r3, #0]
    196a:	202f      	movs	r0, #47	; 0x2f
    196c:	4798      	blx	r3
    196e:	e7fe      	b.n	196e <lcd_ISR+0x16>
    1970:	00004e5f 	.word	0x00004e5f
    1974:	100005f8 	.word	0x100005f8

Disassembly of section .text.gpio_ISR:

00001978 <gpio_ISR>:
	while(1);
}
void gpio_ISR (void) {
    1978:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr gpio");
    197a:	4905      	ldr	r1, [pc, #20]	; (1990 <gpio_ISR+0x18>)
    197c:	2002      	movs	r0, #2
    197e:	f002 fa67 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(48);
    1982:	4b04      	ldr	r3, [pc, #16]	; (1994 <gpio_ISR+0x1c>)
    1984:	681a      	ldr	r2, [r3, #0]
    1986:	b112      	cbz	r2, 198e <gpio_ISR+0x16>
    1988:	681b      	ldr	r3, [r3, #0]
    198a:	2030      	movs	r0, #48	; 0x30
    198c:	4798      	blx	r3
    198e:	e7fe      	b.n	198e <gpio_ISR+0x16>
    1990:	00004e6a 	.word	0x00004e6a
    1994:	100005f8 	.word	0x100005f8

Disassembly of section .text.pwm0_ISR:

00001998 <pwm0_ISR>:
	while(1);
}
void pwm0_ISR (void) {
    1998:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr pwm0");
    199a:	4905      	ldr	r1, [pc, #20]	; (19b0 <pwm0_ISR+0x18>)
    199c:	2002      	movs	r0, #2
    199e:	f002 fa57 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(49);
    19a2:	4b04      	ldr	r3, [pc, #16]	; (19b4 <pwm0_ISR+0x1c>)
    19a4:	681a      	ldr	r2, [r3, #0]
    19a6:	b112      	cbz	r2, 19ae <pwm0_ISR+0x16>
    19a8:	681b      	ldr	r3, [r3, #0]
    19aa:	2031      	movs	r0, #49	; 0x31
    19ac:	4798      	blx	r3
    19ae:	e7fe      	b.n	19ae <pwm0_ISR+0x16>
    19b0:	00004e76 	.word	0x00004e76
    19b4:	100005f8 	.word	0x100005f8

Disassembly of section .text.eeprom_ISR:

000019b8 <eeprom_ISR>:
	while(1);
}
void eeprom_ISR (void) {
    19b8:	b508      	push	{r3, lr}
	#if (VICERR_USE_DEBUG == pdON)
	plognp("vicErr eeprom");
    19ba:	4905      	ldr	r1, [pc, #20]	; (19d0 <eeprom_ISR+0x18>)
    19bc:	2002      	movs	r0, #2
    19be:	f002 fa47 	bl	3e50 <rprintf>
	#endif
	if (vicerr_Functions) vicerr_Functions(50);
    19c2:	4b04      	ldr	r3, [pc, #16]	; (19d4 <eeprom_ISR+0x1c>)
    19c4:	681a      	ldr	r2, [r3, #0]
    19c6:	b112      	cbz	r2, 19ce <eeprom_ISR+0x16>
    19c8:	681b      	ldr	r3, [r3, #0]
    19ca:	2032      	movs	r0, #50	; 0x32
    19cc:	4798      	blx	r3
    19ce:	e7fe      	b.n	19ce <eeprom_ISR+0x16>
    19d0:	00004e82 	.word	0x00004e82
    19d4:	100005f8 	.word	0x100005f8

Disassembly of section .text.nvic_setPendingIRQ:

000019d8 <nvic_setPendingIRQ>:
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_setPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ISER0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    19d8:	0943      	lsrs	r3, r0, #5
    19da:	009b      	lsls	r3, r3, #2
    19dc:	f103 4360 	add.w	r3, r3, #3758096384	; 0xe0000000
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Habilitar a pendencia interrupção do periférico
    19e0:	f000 001f 	and.w	r0, r0, #31
    19e4:	2201      	movs	r2, #1
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_setPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ISER0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    19e6:	f503 4361 	add.w	r3, r3, #57600	; 0xe100
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Habilitar a pendencia interrupção do periférico
    19ea:	fa02 f000 	lsl.w	r0, r2, r0
    19ee:	6018      	str	r0, [r3, #0]
    19f0:	4770      	bx	lr

Disassembly of section .text.nvic_enableIRQ:

000019f2 <nvic_enableIRQ>:
    19f2:	f7ff bff1 	b.w	19d8 <nvic_setPendingIRQ>

Disassembly of section .text.nvic_clearPendingIRQ:

000019f8 <nvic_clearPendingIRQ>:
// Parametro:	ID da interrupção do periférico
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------
void nvic_clearPendingIRQ(u8 numIRQ) {
	reg32 *addrPort = &ICPR0; 		// Pegar o endereço do registrador do periférico
	addrPort+=(reg32)(numIRQ/VIC_SIZE); 	// Determinar em que registrador pertence ao periférico
    19f8:	0942      	lsrs	r2, r0, #5
	*addrPort = (1 << (numIRQ%VIC_SIZE));	// Desabilitar a pendencia interrupção do periférico
    19fa:	2301      	movs	r3, #1
    19fc:	f000 001f 	and.w	r0, r0, #31
    1a00:	fa03 f000 	lsl.w	r0, r3, r0
    1a04:	4b01      	ldr	r3, [pc, #4]	; (1a0c <nvic_clearPendingIRQ+0x14>)
    1a06:	f843 0022 	str.w	r0, [r3, r2, lsl #2]
    1a0a:	4770      	bx	lr
    1a0c:	e000e280 	.word	0xe000e280

Disassembly of section .text.nvic_setPriority:

00001a10 <nvic_setPriority>:
// -----------------------------------------------------------------------------------------------
void nvic_setPriority(s32 numIRQ, u8 priority) {
	#if (VIC_USE_DEBUG == pdON)
	plognp("set pri %d %u"CMD_TERMINATOR, numIRQ, priority);
	#endif
	if(numIRQ < 0) {
    1a10:	2800      	cmp	r0, #0
    1a12:	b2c3      	uxtb	r3, r0
    1a14:	ea4f 01c1 	mov.w	r1, r1, lsl #3
    1a18:	da0d      	bge.n	1a36 <nvic_setPriority+0x26>
		addrPort+=(reg32)(((numIRQ&0xf)-4)/4); 	// Determinar em que registrador pertence ao periférico.
												//   (numIRQ&0xf)-4 para converte o valor negativo
		// cada registrador de 32 bits, guarda a prioridade de 4 periféricos
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		offset+=(reg8)((numIRQ&0xf)-4)%4;
    1a1a:	f000 000f 	and.w	r0, r0, #15
    1a1e:	2204      	movs	r2, #4
    1a20:	3804      	subs	r0, #4
    1a22:	fb90 f0f2 	sdiv	r0, r0, r2
    1a26:	f003 0303 	and.w	r3, r3, #3
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a2a:	4a09      	ldr	r2, [pc, #36]	; (1a50 <nvic_setPriority+0x40>)
		addrPort+=(reg32)(((numIRQ&0xf)-4)/4); 	// Determinar em que registrador pertence ao periférico.
												//   (numIRQ&0xf)-4 para converte o valor negativo
		// cada registrador de 32 bits, guarda a prioridade de 4 periféricos
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		offset+=(reg8)((numIRQ&0xf)-4)%4;
    1a2c:	eb03 0380 	add.w	r3, r3, r0, lsl #2
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a30:	b2c9      	uxtb	r1, r1
    1a32:	5499      	strb	r1, [r3, r2]
    1a34:	4770      	bx	lr
		// logo cada byte é para cada periférico, então precisamo encontrar em que local [e
		reg8 *offset = (reg8*) addrPort;
		#if (VIC_USE_DEBUG == pdON)
		plognp("offset init 0x%x"CMD_TERMINATOR, offset);
		#endif
		offset+=(reg8)numIRQ%4;
    1a36:	f020 0003 	bic.w	r0, r0, #3
    1a3a:	f003 0303 	and.w	r3, r3, #3
    1a3e:	4418      	add	r0, r3
    1a40:	f100 4060 	add.w	r0, r0, #3758096384	; 0xe0000000
    1a44:	f500 4064 	add.w	r0, r0, #58368	; 0xe400
		#if (VIC_USE_DEBUG == pdON)
		plognp("offset 0x%x = 0x%x"CMD_TERMINATOR, offset, ((priority << (8 - VIC_PRIO_BITS)) & 0xff));
		#endif
		*offset = ((priority << (8 - VIC_PRIO_BITS)) & 0xff);
    1a48:	b2c9      	uxtb	r1, r1
    1a4a:	7001      	strb	r1, [r0, #0]
    1a4c:	4770      	bx	lr
    1a4e:	bf00      	nop
    1a50:	e000ed18 	.word	0xe000ed18

Disassembly of section .text.nvic_SetIntHandler:

00001a54 <nvic_SetIntHandler>:
//						}
//						ATENÇÃO: NUNCA USA O DELAY COM INTERRUPÇÃO, USE A LIB COM LOOP, pois se este é um procedimento de erro de
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void nvic_SetIntHandler(void (*func)(int) ) {
	vicerr_Functions = func;
    1a54:	4b01      	ldr	r3, [pc, #4]	; (1a5c <nvic_SetIntHandler+0x8>)
    1a56:	6018      	str	r0, [r3, #0]
    1a58:	4770      	bx	lr
    1a5a:	bf00      	nop
    1a5c:	100005f8 	.word	0x100005f8

Disassembly of section .text.systime_Init:

00001a60 <systime_Init>:
// Parametros:	Nenhum
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
int systime_Init(void) {
	#if (SYSTIME_USE_LED == pdON)
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
    1a60:	4a10      	ldr	r2, [pc, #64]	; (1aa4 <systime_Init+0x44>)

  	systime_ClearIntHandler(); // retira qualquer função anexada para interrupção do systime
  	countTicks_ms = 0; // Limpa o contador de ticks do sistema

	return pdPASS;
}
    1a62:	2001      	movs	r0, #1
// Parametros:	Nenhum
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
int systime_Init(void) {
	#if (SYSTIME_USE_LED == pdON)
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
    1a64:	6813      	ldr	r3, [r2, #0]
    1a66:	f043 5380 	orr.w	r3, r3, #268435456	; 0x10000000
    1a6a:	6013      	str	r3, [r2, #0]
	countTicksLed = 0;
    1a6c:	4b0e      	ldr	r3, [pc, #56]	; (1aa8 <systime_Init+0x48>)
    1a6e:	2200      	movs	r2, #0
    1a70:	601a      	str	r2, [r3, #0]
	#endif

	// Make PendSV and SysTick the lowest priority interrupts
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 16UL );
    1a72:	4b0e      	ldr	r3, [pc, #56]	; (1aac <systime_Init+0x4c>)
    1a74:	6819      	ldr	r1, [r3, #0]
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 24UL );

	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
    1a76:	f6a3 530c 	subw	r3, r3, #3340	; 0xd0c
	ledSYSTIME_DIR |= ledSYSTIME; 					// Colocar o pino do led para saida
	countTicksLed = 0;
	#endif

	// Make PendSV and SysTick the lowest priority interrupts
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 16UL );
    1a7a:	f441 0178 	orr.w	r1, r1, #16252928	; 0xf80000
    1a7e:	f8c3 1d0c 	str.w	r1, [r3, #3340]	; 0xd0c
	NVIC_SYSPRI2_REG |= ( ( ( u32 ) configINTERRUPT_PRIORITY ) << 24UL );
    1a82:	f8d3 1d0c 	ldr.w	r1, [r3, #3340]	; 0xd0c
    1a86:	f041 4178 	orr.w	r1, r1, #4160749568	; 0xf8000000
    1a8a:	f8c3 1d0c 	str.w	r1, [r3, #3340]	; 0xd0c

	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
    1a8e:	4908      	ldr	r1, [pc, #32]	; (1ab0 <systime_Init+0x50>)
    1a90:	6019      	str	r1, [r3, #0]
	STCTRL = ( STCTRL_CLKSOURCE | STCTRL_TICKINT | STCTRL_ENABLE );
    1a92:	2107      	movs	r1, #7
    1a94:	f843 1c04 	str.w	r1, [r3, #-4]
// Descrição: 	Retira a routina da inetrrupçao desejada do vetor de interrupções
// Parametros:	Nenhum
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void systime_ClearIntHandler(void) {
	systime_IntFunctions = 0;
    1a98:	4b06      	ldr	r3, [pc, #24]	; (1ab4 <systime_Init+0x54>)
    1a9a:	601a      	str	r2, [r3, #0]
	// Configure SysTick to interrupt at the requested rate.
	STRELOAD = ( CCLK / 1000 / SYSTIME_BASE_TICK ) - 1UL;
	STCTRL = ( STCTRL_CLKSOURCE | STCTRL_TICKINT | STCTRL_ENABLE );

  	systime_ClearIntHandler(); // retira qualquer função anexada para interrupção do systime
  	countTicks_ms = 0; // Limpa o contador de ticks do sistema
    1a9c:	4b06      	ldr	r3, [pc, #24]	; (1ab8 <systime_Init+0x58>)
    1a9e:	601a      	str	r2, [r3, #0]

	return pdPASS;
}
    1aa0:	4770      	bx	lr
    1aa2:	bf00      	nop
    1aa4:	2009c080 	.word	0x2009c080
    1aa8:	100005fc 	.word	0x100005fc
    1aac:	e000ed20 	.word	0xe000ed20
    1ab0:	0001869f 	.word	0x0001869f
    1ab4:	10000608 	.word	0x10000608
    1ab8:	10000600 	.word	0x10000600

Disassembly of section .text.systime_SetIntHandler:

00001abc <systime_SetIntHandler>:
//					Ponteiro da rotina que tratará a interrupção do timer.
//					Ex:	systime_SetIntHandler(myOverflowFunction, xticks);
//				xticks: Quantidade de ticks que a função deve ser chamada. Consultar SYSTIME_BASE_TICK
// Retorna:		Nada
// ----------------------------------------------------------------------------------------------------------------
void systime_SetIntHandler(void (*int_func)(void), uint xticks ) {
    1abc:	4b02      	ldr	r3, [pc, #8]	; (1ac8 <systime_SetIntHandler+0xc>)
	if (xticks == 0) { systime_IntFunctions = 0; return;}
    1abe:	b109      	cbz	r1, 1ac4 <systime_SetIntHandler+0x8>
	systime_IntFunctions = int_func;
    1ac0:	6018      	str	r0, [r3, #0]
	callfuncTime = xticks;
    1ac2:	4b02      	ldr	r3, [pc, #8]	; (1acc <systime_SetIntHandler+0x10>)
    1ac4:	6019      	str	r1, [r3, #0]
    1ac6:	4770      	bx	lr
    1ac8:	10000608 	.word	0x10000608
    1acc:	10000604 	.word	0x10000604

Disassembly of section .text.sysTick_ISR:

00001ad0 <sysTick_ISR>:

// ################################################################################################################
// SYSTEM TIMER INTERRUPÇÃO
// ################################################################################################################
// ################################################################################################################
void sysTick_ISR (void) {
    1ad0:	b508      	push	{r3, lr}
    ISR_ENTRY;	// Procedimento para entrada da interrupção

	countTicks_ms++;
    1ad2:	4b12      	ldr	r3, [pc, #72]	; (1b1c <sysTick_ISR+0x4c>)

	// Checa se existe uma função anexada a interrupção e é tempo de chamar a função
	if ( (systime_IntFunctions) && (countTicks_ms % callfuncTime == 0))
    1ad4:	4912      	ldr	r1, [pc, #72]	; (1b20 <sysTick_ISR+0x50>)
// ################################################################################################################
// ################################################################################################################
void sysTick_ISR (void) {
    ISR_ENTRY;	// Procedimento para entrada da interrupção

	countTicks_ms++;
    1ad6:	681a      	ldr	r2, [r3, #0]
    1ad8:	3201      	adds	r2, #1
    1ada:	601a      	str	r2, [r3, #0]

	// Checa se existe uma função anexada a interrupção e é tempo de chamar a função
	if ( (systime_IntFunctions) && (countTicks_ms % callfuncTime == 0))
    1adc:	680a      	ldr	r2, [r1, #0]
    1ade:	b14a      	cbz	r2, 1af4 <sysTick_ISR+0x24>
    1ae0:	6818      	ldr	r0, [r3, #0]
    1ae2:	4b10      	ldr	r3, [pc, #64]	; (1b24 <sysTick_ISR+0x54>)
    1ae4:	681b      	ldr	r3, [r3, #0]
    1ae6:	fbb0 f2f3 	udiv	r2, r0, r3
    1aea:	fb03 0312 	mls	r3, r3, r2, r0
    1aee:	b90b      	cbnz	r3, 1af4 <sysTick_ISR+0x24>
		systime_IntFunctions();					// Execute a função anexada
    1af0:	680b      	ldr	r3, [r1, #0]
    1af2:	4798      	blx	r3

	#if (SYSTIME_USE_LED == pdON)
	if (countTicksLed >= SYSTIME_LED_OFF_MS*SYSTIME_BASE_TICK + SYSTIME_LED_ON_MS*SYSTIME_BASE_TICK)
    1af4:	4b0c      	ldr	r3, [pc, #48]	; (1b28 <sysTick_ISR+0x58>)
    1af6:	681a      	ldr	r2, [r3, #0]
    1af8:	f5b2 7f7a 	cmp.w	r2, #1000	; 0x3e8
		countTicksLed = 0;
    1afc:	bf24      	itt	cs
    1afe:	2200      	movcs	r2, #0
    1b00:	601a      	strcs	r2, [r3, #0]
		countTicksLed++;
    1b02:	681a      	ldr	r2, [r3, #0]
    1b04:	3201      	adds	r2, #1
    1b06:	601a      	str	r2, [r3, #0]
		if (countTicksLed > SYSTIME_LED_OFF_MS*SYSTIME_BASE_TICK) {
    1b08:	681b      	ldr	r3, [r3, #0]
    1b0a:	f5b3 7f61 	cmp.w	r3, #900	; 0x384
			ledSYSTIME_ON = ledSYSTIME;
    1b0e:	bf8c      	ite	hi
    1b10:	4a06      	ldrhi	r2, [pc, #24]	; (1b2c <sysTick_ISR+0x5c>)
		} else {
			ledSYSTIME_OFF = ledSYSTIME;
    1b12:	4a07      	ldrls	r2, [pc, #28]	; (1b30 <sysTick_ISR+0x60>)
    1b14:	f04f 5380 	mov.w	r3, #268435456	; 0x10000000
    1b18:	6013      	str	r3, [r2, #0]
    1b1a:	bd08      	pop	{r3, pc}
    1b1c:	10000600 	.word	0x10000600
    1b20:	10000608 	.word	0x10000608
    1b24:	10000604 	.word	0x10000604
    1b28:	100005fc 	.word	0x100005fc
    1b2c:	2009c098 	.word	0x2009c098
    1b30:	2009c09c 	.word	0x2009c09c

Disassembly of section .text.delay:

00001b34 <delay>:
*/

#include "delay.h"

void delay(u32 delayval) {
	asm volatile (
    1b34:	3801      	subs	r0, #1
    1b36:	d1fd      	bne.n	1b34 <delay>
    1b38:	4770      	bx	lr

Disassembly of section .text.uart0_SetBaudrate:

00001b40 <uart0_SetBaudrate>:
		}
	}
	return r;
}

void uart0_SetBaudrate(u32 baudrate) {
    1b40:	e92d 4ff7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    1b44:	4680      	mov	r8, r0
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1b46:	4e34      	ldr	r6, [pc, #208]	; (1c18 <uart0_SetBaudrate+0xd8>)
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1b48:	4834      	ldr	r0, [pc, #208]	; (1c1c <uart0_SetBaudrate+0xdc>)
	}
	return r;
}

void uart0_SetBaudrate(u32 baudrate) {
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1b4a:	2380      	movs	r3, #128	; 0x80
    1b4c:	6033      	str	r3, [r6, #0]
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1b4e:	fb90 f0f8 	sdiv	r0, r0, r8
    1b52:	f7fe fd25 	bl	5a0 <__aeabi_i2d>
    1b56:	a32c      	add	r3, pc, #176	; (adr r3, 1c08 <uart0_SetBaudrate+0xc8>)
    1b58:	e9d3 2300 	ldrd	r2, r3, [r3]
    1b5c:	f7fe fd86 	bl	66c <__aeabi_dmul>
    1b60:	f7ff f81e 	bl	ba0 <__aeabi_d2iz>
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
    1b64:	46c2      	mov	sl, r8
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1b66:	4607      	mov	r7, r0

void uart0_SetBaudrate(u32 baudrate) {
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U0DLL = f_div%256;        								// Ajusta o baudrate byte baixo
    1b68:	4b2d      	ldr	r3, [pc, #180]	; (1c20 <uart0_SetBaudrate+0xe0>)
    1b6a:	b2c2      	uxtb	r2, r0
    1b6c:	601a      	str	r2, [r3, #0]
  	U0DLM = f_div/256;    									// Ajusta o baudrate byte alto
    1b6e:	0a02      	lsrs	r2, r0, #8
    1b70:	605a      	str	r2, [r3, #4]
//	fraction = BAUD*(1+D/M)
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
    1b72:	f04f 0910 	mov.w	r9, #16
	e = baud;
	for(m=1;m<=15;m++) {
    1b76:	2401      	movs	r4, #1
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
				e = abs(baud-b);
				r = (m<<4) + d;
    1b78:	ea4f 1b04 	mov.w	fp, r4, lsl #4
    1b7c:	2500      	movs	r5, #0
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1b7e:	4628      	mov	r0, r5
    1b80:	f7ff f8f0 	bl	d64 <__aeabi_i2f>
    1b84:	9001      	str	r0, [sp, #4]
    1b86:	4620      	mov	r0, r4
    1b88:	f7ff f8ec 	bl	d64 <__aeabi_i2f>
    1b8c:	9b01      	ldr	r3, [sp, #4]
    1b8e:	4601      	mov	r1, r0
    1b90:	4618      	mov	r0, r3
    1b92:	f7ff f9ef 	bl	f74 <__aeabi_fdiv>
    1b96:	f04f 517e 	mov.w	r1, #1065353216	; 0x3f800000
    1b9a:	f7ff f82f 	bl	bfc <__addsf3>
    1b9e:	9001      	str	r0, [sp, #4]
    1ba0:	4638      	mov	r0, r7
    1ba2:	f7ff f8df 	bl	d64 <__aeabi_i2f>
    1ba6:	9b01      	ldr	r3, [sp, #4]
    1ba8:	4601      	mov	r1, r0
    1baa:	4618      	mov	r0, r3
    1bac:	f7ff f92e 	bl	e0c <__aeabi_fmul>
    1bb0:	f7fe fd08 	bl	5c4 <__aeabi_f2d>
    1bb4:	2200      	movs	r2, #0
    1bb6:	4b1b      	ldr	r3, [pc, #108]	; (1c24 <uart0_SetBaudrate+0xe4>)
    1bb8:	f7fe fd58 	bl	66c <__aeabi_dmul>
    1bbc:	4602      	mov	r2, r0
    1bbe:	460b      	mov	r3, r1
    1bc0:	a113      	add	r1, pc, #76	; (adr r1, 1c10 <uart0_SetBaudrate+0xd0>)
    1bc2:	e9d1 0100 	ldrd	r0, r1, [r1]
    1bc6:	f7fe fe7b 	bl	8c0 <__aeabi_ddiv>
    1bca:	f7fe ffe9 	bl	ba0 <__aeabi_d2iz>
    1bce:	ebc0 0008 	rsb	r0, r0, r8
    1bd2:	2800      	cmp	r0, #0
    1bd4:	bfb8      	it	lt
    1bd6:	4240      	neglt	r0, r0
    1bd8:	4550      	cmp	r0, sl
    1bda:	bfb8      	it	lt
    1bdc:	eb05 090b 	addlt.w	r9, r5, fp
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1be0:	f105 0501 	add.w	r5, r5, #1
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1be4:	bfb8      	it	lt
    1be6:	4682      	movlt	sl, r0
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1be8:	42ac      	cmp	r4, r5
    1bea:	d1c8      	bne.n	1b7e <uart0_SetBaudrate+0x3e>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
    1bec:	3401      	adds	r4, #1
    1bee:	2c10      	cmp	r4, #16
    1bf0:	d1c2      	bne.n	1b78 <uart0_SetBaudrate+0x38>
  	U0LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U0DLL = f_div%256;        								// Ajusta o baudrate byte baixo
  	U0DLM = f_div/256;    									// Ajusta o baudrate byte alto
  	U0FDR = uart_fdr(baudrate);
    1bf2:	4b0d      	ldr	r3, [pc, #52]	; (1c28 <uart0_SetBaudrate+0xe8>)
    1bf4:	f8c3 9000 	str.w	r9, [r3]
	U0LCR = (UART0_MODE & ~U0LCR_DLAB_ENABLE);					// Configura o modo de trabalho da uart e desativa o acesso aos registradores do baudrate
    1bf8:	2303      	movs	r3, #3
    1bfa:	6033      	str	r3, [r6, #0]
}
    1bfc:	b003      	add	sp, #12
    1bfe:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
    1c02:	bf00      	nop
    1c04:	f3af 8000 	nop.w
    1c08:	9999999a 	.word	0x9999999a
    1c0c:	3fe99999 	.word	0x3fe99999
    1c10:	00000000 	.word	0x00000000
    1c14:	4177d784 	.word	0x4177d784
    1c18:	4000c00c 	.word	0x4000c00c
    1c1c:	0017d784 	.word	0x0017d784
    1c20:	4000c000 	.word	0x4000c000
    1c24:	40300000 	.word	0x40300000
    1c28:	4000c028 	.word	0x4000c028

Disassembly of section .text.uart0_Init:

00001c2c <uart0_Init>:
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c2c:	4a1f      	ldr	r2, [pc, #124]	; (1cac <uart0_Init+0x80>)
// Descrição: 	Incializa e configura o modo de trabalho da UART
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
    1c2e:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c32:	6813      	ldr	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c34:	4c1e      	ldr	r4, [pc, #120]	; (1cb0 <uart0_Init+0x84>)
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_Init(u32 baudrate) {
  	PCONP |= PCUART0;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1c36:	f043 0308 	orr.w	r3, r3, #8
    1c3a:	6013      	str	r3, [r2, #0]
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c3c:	4a1d      	ldr	r2, [pc, #116]	; (1cb4 <uart0_Init+0x88>)
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1c3e:	4d1e      	ldr	r5, [pc, #120]	; (1cb8 <uart0_Init+0x8c>)
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c40:	6813      	ldr	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c42:	2600      	movs	r6, #0
	#if defined(arm7tdmi)
  	U0_PINSEL = (U0_PINSEL & ~U0_PINMASK) | U0_PINS;			// Configura os pinos do uC para a função UART. Pinos TX=P0_2 e RX=P0_3
	#endif //arm7tdmi

	#if defined(cortexm3)
  	uart0_ConfigPort();
    1c44:	f043 0350 	orr.w	r3, r3, #80	; 0x50
    1c48:	6013      	str	r3, [r2, #0]
	U0_CTS_DIR &= ~U0_CTS; 				// Pino CTS como entrada
	U0_RTS_DIR |= U0_RTS; 				// Pino RTS como saída
	uart0_RTSon(); 						// Sinaliza que posso receber dados
  	#endif

  	U0IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1c4a:	6026      	str	r6, [r4, #0]
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1c4c:	682b      	ldr	r3, [r5, #0]
	U0FCR = (U0FCR_TX_FIFO_RESET | U0FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
    1c4e:	2306      	movs	r3, #6
    1c50:	602b      	str	r3, [r5, #0]
  	
  	uart0_SetBaudrate(baudrate);
    1c52:	f7ff ff75 	bl	1b40 <uart0_SetBaudrate>

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1c56:	2701      	movs	r7, #1
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
    1c58:	4b18      	ldr	r3, [pc, #96]	; (1cbc <uart0_Init+0x90>)
  	U0IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
	U0FCR = (U0FCR_TX_FIFO_RESET | U0FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
  	
  	uart0_SetBaudrate(baudrate);

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1c5a:	602f      	str	r7, [r5, #0]
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
    1c5c:	681b      	ldr	r3, [r3, #0]
  	U0LSR;                                						// Limpa o registrador de estado de linha
    1c5e:	4b18      	ldr	r3, [pc, #96]	; (1cc0 <uart0_Init+0x94>)
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
  	U0FCR = U0FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    1c60:	f04f 0804 	mov.w	r8, #4
  	uart0_SetBaudrate(baudrate);

  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
  	U0LSR;                                						// Limpa o registrador de estado de linha
    1c64:	681b      	ldr	r3, [r3, #0]
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
    1c66:	2302      	movs	r3, #2
    1c68:	602b      	str	r3, [r5, #0]
  	if (!irq_Install(VIC_UART0, uart0_ISR, UART0_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART0);
    1c6a:	2005      	movs	r0, #5
  	U0FCR = UART0_FIFOMODE;										// Configura o modo de trabalho da FIFO
  	
  	U0RBR;                                						// Limpa o registrador de recepçao de dados
  	U0LSR;                                						// Limpa o registrador de estado de linha
	U0FCR = U0FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
  	U0FCR = U0FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    1c6c:	f8c5 8000 	str.w	r8, [r5]
  	if (!irq_Install(VIC_UART0, uart0_ISR, UART0_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART0);
    1c70:	f7ff febf 	bl	19f2 <nvic_enableIRQ>
	nvic_setPriority(VIC_UART0, UART0_PRIO_LEVEL);
    1c74:	4641      	mov	r1, r8
    1c76:	2005      	movs	r0, #5
    1c78:	f7ff feca 	bl	1a10 <nvic_setPriority>
	#if (USE_MALLOC == pdON)
	u0_data_rx = malloc(UART0_RX_BUFFER_SIZE*sizeof(u8));
	u0_data_tx = malloc(UART0_TX_BUFFER_SIZE*sizeof(u8));
	#endif

	buffer_Init(&u0_buf_rx, u0_data_rx, UART0_RX_BUFFER_SIZE);
    1c7c:	2296      	movs	r2, #150	; 0x96
    1c7e:	4911      	ldr	r1, [pc, #68]	; (1cc4 <uart0_Init+0x98>)
    1c80:	4811      	ldr	r0, [pc, #68]	; (1cc8 <uart0_Init+0x9c>)
    1c82:	f002 f90f 	bl	3ea4 <buffer_Init>
	buffer_Init(&u0_buf_tx, u0_data_tx, UART0_TX_BUFFER_SIZE);
    1c86:	2296      	movs	r2, #150	; 0x96
    1c88:	4910      	ldr	r1, [pc, #64]	; (1ccc <uart0_Init+0xa0>)
    1c8a:	4811      	ldr	r0, [pc, #68]	; (1cd0 <uart0_Init+0xa4>)
    1c8c:	f002 f90a 	bl	3ea4 <buffer_Init>
		
	u0_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1c90:	4b10      	ldr	r3, [pc, #64]	; (1cd4 <uart0_Init+0xa8>)
	
	U0IER |= U0IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
	U0IER &= ~U0IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão

	return pdPASS;
}
    1c92:	4638      	mov	r0, r7
	#endif

	buffer_Init(&u0_buf_rx, u0_data_rx, UART0_RX_BUFFER_SIZE);
	buffer_Init(&u0_buf_tx, u0_data_tx, UART0_TX_BUFFER_SIZE);
		
	u0_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1c94:	801e      	strh	r6, [r3, #0]
	u0_tx_running = pdFALSE;
    1c96:	4b10      	ldr	r3, [pc, #64]	; (1cd8 <uart0_Init+0xac>)
    1c98:	701e      	strb	r6, [r3, #0]
	
	U0IER |= U0IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1c9a:	6823      	ldr	r3, [r4, #0]
    1c9c:	433b      	orrs	r3, r7
    1c9e:	6023      	str	r3, [r4, #0]
	U0IER &= ~U0IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão
    1ca0:	6823      	ldr	r3, [r4, #0]
    1ca2:	f023 0302 	bic.w	r3, r3, #2
    1ca6:	6023      	str	r3, [r4, #0]

	return pdPASS;
}
    1ca8:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    1cac:	400fc0c4 	.word	0x400fc0c4
    1cb0:	4000c004 	.word	0x4000c004
    1cb4:	4002c000 	.word	0x4002c000
    1cb8:	4000c008 	.word	0x4000c008
    1cbc:	4000c000 	.word	0x4000c000
    1cc0:	4000c014 	.word	0x4000c014
    1cc4:	100006c0 	.word	0x100006c0
    1cc8:	100006a8 	.word	0x100006a8
    1ccc:	1000060c 	.word	0x1000060c
    1cd0:	100006b4 	.word	0x100006b4
    1cd4:	100006a4 	.word	0x100006a4
    1cd8:	100006a2 	.word	0x100006a2

Disassembly of section .text.uart0_GetChar:

00001cdc <uart0_GetChar>:
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Captura o próximo byte recebido na UART
// Parametros: 	Ponteiro para da variavel char para o retorno do byte recebido
// Retorna:		pdPASS indicando que existe caractere recebido ou o código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_GetChar(u8 *ch) {
    1cdc:	b538      	push	{r3, r4, r5, lr}
    1cde:	4605      	mov	r5, r0
	int ret;

	if ( u0_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
    1ce0:	480d      	ldr	r0, [pc, #52]	; (1d18 <uart0_GetChar+0x3c>)
    1ce2:	8883      	ldrh	r3, [r0, #4]
    1ce4:	b29b      	uxth	r3, r3
    1ce6:	b18b      	cbz	r3, 1d0c <uart0_GetChar+0x30>
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro

	if ( u0_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
    1ce8:	88c3      	ldrh	r3, [r0, #6]
    1cea:	b29b      	uxth	r3, r3
    1cec:	b18b      	cbz	r3, 1d12 <uart0_GetChar+0x36>
		U0IER &= ~U0IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1cee:	4c0b      	ldr	r4, [pc, #44]	; (1d1c <uart0_GetChar+0x40>)
    1cf0:	6823      	ldr	r3, [r4, #0]
    1cf2:	f023 0301 	bic.w	r3, r3, #1
    1cf6:	6023      	str	r3, [r4, #0]
		nop();
    1cf8:	bf00      	nop
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
    1cfa:	f002 f8d9 	bl	3eb0 <buffer_GetFromFront>
    1cfe:	7028      	strb	r0, [r5, #0]
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d00:	6823      	ldr	r3, [r4, #0]
		ret = pdPASS;
    1d02:	2001      	movs	r0, #1

	if ( u0_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
		U0IER &= ~U0IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		nop();
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1d04:	f043 0301 	orr.w	r3, r3, #1
    1d08:	6023      	str	r3, [r4, #0]
    1d0a:	bd38      	pop	{r3, r4, r5, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart0_GetChar(u8 *ch) {
	int ret;

	if ( u0_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro
    1d0c:	f06f 000b 	mvn.w	r0, #11
    1d10:	bd38      	pop	{r3, r4, r5, pc}
		nop();
		*ch = buffer_GetFromFront(&u0_buf_rx);				// Captura os dados do inicio do buffer
		U0IER |= U0IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		ret = pdPASS;
	} else
		ret = errBUFFER_EMPTY;
    1d12:	f06f 000a 	mvn.w	r0, #10

	return ret;
}
    1d16:	bd38      	pop	{r3, r4, r5, pc}
    1d18:	100006a8 	.word	0x100006a8
    1d1c:	4000c004 	.word	0x4000c004

Disassembly of section .text.uart0_PutChar:

00001d20 <uart0_PutChar>:
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    1d20:	4b15      	ldr	r3, [pc, #84]	; (1d78 <uart0_PutChar+0x58>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Coloca um caractere na fila de transmissão
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
    1d22:	b570      	push	{r4, r5, r6, lr}
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    1d24:	889b      	ldrh	r3, [r3, #4]
    1d26:	b29b      	uxth	r3, r3
    1d28:	b303      	cbz	r3, 1d6c <uart0_PutChar+0x4c>
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
    1d2a:	4c14      	ldr	r4, [pc, #80]	; (1d7c <uart0_PutChar+0x5c>)
		nop();
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
    1d2c:	b2c5      	uxtb	r5, r0
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
    1d2e:	6823      	ldr	r3, [r4, #0]
    1d30:	4e12      	ldr	r6, [pc, #72]	; (1d7c <uart0_PutChar+0x5c>)
    1d32:	f023 0302 	bic.w	r3, r3, #2
    1d36:	6023      	str	r3, [r4, #0]
		nop();
    1d38:	bf00      	nop
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
    1d3a:	480f      	ldr	r0, [pc, #60]	; (1d78 <uart0_PutChar+0x58>)
    1d3c:	4629      	mov	r1, r5
    1d3e:	f002 f8d9 	bl	3ef4 <buffer_AddToEnd>
		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d42:	6823      	ldr	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    1d44:	300a      	adds	r0, #10

	do {
		U0IER &= ~U0IER_ETBEI;                 								// Desabilita a interrupção de transmissão
		nop();
		sts = buffer_AddToEnd(&u0_buf_tx, ch);
		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d46:	f043 0302 	orr.w	r3, r3, #2
    1d4a:	6023      	str	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    1d4c:	d0ef      	beq.n	1d2e <uart0_PutChar+0xe>

	if (!u0_tx_running) {													// Checa se existe dado sendo transmitido
    1d4e:	4c0c      	ldr	r4, [pc, #48]	; (1d80 <uart0_PutChar+0x60>)
    1d50:	7823      	ldrb	r3, [r4, #0]
    1d52:	b973      	cbnz	r3, 1d72 <uart0_PutChar+0x52>
  		U0THR = buffer_GetFromFront(&u0_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
    1d54:	4808      	ldr	r0, [pc, #32]	; (1d78 <uart0_PutChar+0x58>)
    1d56:	f002 f8ab 	bl	3eb0 <buffer_GetFromFront>
    1d5a:	4b0a      	ldr	r3, [pc, #40]	; (1d84 <uart0_PutChar+0x64>)
    1d5c:	6018      	str	r0, [r3, #0]
  		u0_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
    1d5e:	2001      	movs	r0, #1
    1d60:	7020      	strb	r0, [r4, #0]
  		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
    1d62:	6833      	ldr	r3, [r6, #0]
    1d64:	f043 0302 	orr.w	r3, r3, #2
    1d68:	6033      	str	r3, [r6, #0]
    1d6a:	bd70      	pop	{r4, r5, r6, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart0_PutChar(n16 ch) {
	int sts;

	if ( u0_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
   		return errBUFFER_NO_EXIST;                          				// Retorna indicando erro
    1d6c:	f06f 000b 	mvn.w	r0, #11
    1d70:	bd70      	pop	{r4, r5, r6, pc}
  		U0THR = buffer_GetFromFront(&u0_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
  		u0_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
  		U0IER |= U0IER_ETBEI;                  								// Habilita a interrupção de transmissão
   	}

  	return pdPASS;
    1d72:	2001      	movs	r0, #1
}
    1d74:	bd70      	pop	{r4, r5, r6, pc}
    1d76:	bf00      	nop
    1d78:	100006b4 	.word	0x100006b4
    1d7c:	4000c004 	.word	0x4000c004
    1d80:	100006a2 	.word	0x100006a2
    1d84:	4000c000 	.word	0x4000c000

Disassembly of section .text.uart0_BasicPutChar:

00001d88 <uart0_BasicPutChar>:
// Descrição:	Coloca um caractere na fila de transmissão. FUNÇÃO UTIL PARA DEBUG ONDE NÃO PRECISA INICIAR IRQ ou OS
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart0_BasicPutChar(n16 ch) {
  	while (!(U0LSR & U0LSR_THRE))								// Espero até que o buffer TX fique vazio
    1d88:	4a04      	ldr	r2, [pc, #16]	; (1d9c <uart0_BasicPutChar+0x14>)
    1d8a:	6813      	ldr	r3, [r2, #0]
    1d8c:	069b      	lsls	r3, r3, #26
    1d8e:	d5fc      	bpl.n	1d8a <uart0_BasicPutChar+0x2>
  		CRITICAL_WAIT;        									// Caso exista algum OS, pode trocar de contexto
  	U0THR = (u8)ch;												// Atualiza o registrador de TX uart com o dado
    1d90:	4b03      	ldr	r3, [pc, #12]	; (1da0 <uart0_BasicPutChar+0x18>)
    1d92:	b2c0      	uxtb	r0, r0
    1d94:	6018      	str	r0, [r3, #0]
	return pdPASS;
}
    1d96:	2001      	movs	r0, #1
    1d98:	4770      	bx	lr
    1d9a:	bf00      	nop
    1d9c:	4000c014 	.word	0x4000c014
    1da0:	4000c000 	.word	0x4000c000

Disassembly of section .text.uart0_ISR:

00001da4 <uart0_ISR>:
//###################################################################################################################
// UART SERVIÇO DE INTERRUPÇÕES
// 		Descrição: 	Esta função implementa o ISR da UART0
//###################################################################################################################
//###################################################################################################################
void uart0_ISR (void) {
    1da4:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;
 	 	
  	while ( !((int_flags = U0IIR) & U0IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART 	
    1da8:	4e23      	ldr	r6, [pc, #140]	; (1e38 <uart0_ISR+0x94>)
    1daa:	4c24      	ldr	r4, [pc, #144]	; (1e3c <uart0_ISR+0x98>)
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
      	case U0IIR_THRE_INT:               									// Interrupção da FIFO de 16 bytes quando está vazia
        	while (U0LSR & U0LSR_THRE) {									// Faça enquanto há espaço na FIFO
        		if (buffer_IsEmpty(&u0_buf_tx) ) {							// Checa se o buffer de transmissão já está vazio
        			u0_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
        			U0IER &= ~U0IER_ETBEI;                					// Desativa a interrupção de transmissão
    1dac:	4d24      	ldr	r5, [pc, #144]	; (1e40 <uart0_ISR+0x9c>)
void uart0_ISR (void) {
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;
 	 	
  	while ( !((int_flags = U0IIR) & U0IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART 	
    1dae:	6833      	ldr	r3, [r6, #0]
    1db0:	b2db      	uxtb	r3, r3
    1db2:	07da      	lsls	r2, r3, #31
    1db4:	d43a      	bmi.n	1e2c <uart0_ISR+0x88>
    	switch (int_flags & U0IIR_ID_MASK) {									// Identifica a fonte de interrupção
    1db6:	f003 030e 	and.w	r3, r3, #14
    1dba:	3b02      	subs	r3, #2
    1dbc:	2b0a      	cmp	r3, #10
    1dbe:	d831      	bhi.n	1e24 <uart0_ISR+0x80>
    1dc0:	e8df f003 	tbb	[pc, r3]
    1dc4:	3008301b 	.word	0x3008301b
    1dc8:	30303006 	.word	0x30303006
    1dcc:	3030      	.short	0x3030
    1dce:	08          	.byte	0x08
    1dcf:	00          	.byte	0x00
      	case U0IIR_RLS_INT:                									// Caso recebeu uma INT de erro na linha de recepção (receive line status)
        	U0LSR;                          								// Limpa registrador de status de linha
    1dd0:	6823      	ldr	r3, [r4, #0]
        	break;
    1dd2:	e7ec      	b.n	1dae <uart0_ISR+0xa>
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U0IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U0IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
      		do { 
      			if (buffer_AddToEnd(&u0_buf_rx, U0RBR) == errBUFFER_FULL)
    1dd4:	f8df 8074 	ldr.w	r8, [pc, #116]	; 1e4c <uart0_ISR+0xa8>
					u0_overflow_rx++;
    1dd8:	4f1a      	ldr	r7, [pc, #104]	; (1e44 <uart0_ISR+0xa0>)
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U0IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U0IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
      		do { 
      			if (buffer_AddToEnd(&u0_buf_rx, U0RBR) == errBUFFER_FULL)
    1dda:	f8d8 1000 	ldr.w	r1, [r8]
    1dde:	481a      	ldr	r0, [pc, #104]	; (1e48 <uart0_ISR+0xa4>)
    1de0:	b2c9      	uxtb	r1, r1
    1de2:	f002 f887 	bl	3ef4 <buffer_AddToEnd>
    1de6:	300a      	adds	r0, #10
					u0_overflow_rx++;
    1de8:	bf01      	itttt	eq
    1dea:	883b      	ldrheq	r3, [r7, #0]
    1dec:	3301      	addeq	r3, #1
    1dee:	b29b      	uxtheq	r3, r3
    1df0:	803b      	strheq	r3, [r7, #0]
      		} while(U0LSR & U0LSR_RDR);										// Faça enquanto existe dados validos na FIFO de recepção
    1df2:	6823      	ldr	r3, [r4, #0]
    1df4:	07d8      	lsls	r0, r3, #31
    1df6:	d4f0      	bmi.n	1dda <uart0_ISR+0x36>
    1df8:	e7d9      	b.n	1dae <uart0_ISR+0xa>
            		break;
          		} else {
					#if (UART0_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart0_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	          			U0THR = buffer_GetFromFront(&u0_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    1dfa:	4f14      	ldr	r7, [pc, #80]	; (1e4c <uart0_ISR+0xa8>)

     	// RETIRA OS DADOS DO BUFFER TX PARA A FIFO DE TRANSMISSÃO
     		// Essa interrupção é gerada quando a FIFO de transmissão de 16 bytes está vazia
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
      	case U0IIR_THRE_INT:               									// Interrupção da FIFO de 16 bytes quando está vazia
        	while (U0LSR & U0LSR_THRE) {									// Faça enquanto há espaço na FIFO
    1dfc:	6823      	ldr	r3, [r4, #0]
    1dfe:	0699      	lsls	r1, r3, #26
    1e00:	d5d5      	bpl.n	1dae <uart0_ISR+0xa>
        		if (buffer_IsEmpty(&u0_buf_tx) ) {							// Checa se o buffer de transmissão já está vazio
    1e02:	4813      	ldr	r0, [pc, #76]	; (1e50 <uart0_ISR+0xac>)
    1e04:	f002 f893 	bl	3f2e <buffer_IsEmpty>
    1e08:	b138      	cbz	r0, 1e1a <uart0_ISR+0x76>
        			u0_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
    1e0a:	4b12      	ldr	r3, [pc, #72]	; (1e54 <uart0_ISR+0xb0>)
    1e0c:	2200      	movs	r2, #0
    1e0e:	701a      	strb	r2, [r3, #0]
        			U0IER &= ~U0IER_ETBEI;                					// Desativa a interrupção de transmissão
    1e10:	682b      	ldr	r3, [r5, #0]
    1e12:	f023 0302 	bic.w	r3, r3, #2
    1e16:	602b      	str	r3, [r5, #0]
            		break;
    1e18:	e7c9      	b.n	1dae <uart0_ISR+0xa>
          		} else {
					#if (UART0_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart0_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	          			U0THR = buffer_GetFromFront(&u0_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    1e1a:	480d      	ldr	r0, [pc, #52]	; (1e50 <uart0_ISR+0xac>)
    1e1c:	f002 f848 	bl	3eb0 <buffer_GetFromFront>
    1e20:	6038      	str	r0, [r7, #0]
    1e22:	e7eb      	b.n	1dfc <uart0_ISR+0x58>
          	}
		    
		    break;

      	default:															// Interrupção desconhecida
        	U0LSR;															// Limpa registrador de status de linha
    1e24:	6823      	ldr	r3, [r4, #0]
        	U0RBR;															// Limpa o registrador de recepçao de dados
    1e26:	4b09      	ldr	r3, [pc, #36]	; (1e4c <uart0_ISR+0xa8>)
    1e28:	681b      	ldr	r3, [r3, #0]
	       	break;
    1e2a:	e7c0      	b.n	1dae <uart0_ISR+0xa>
	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART0);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART0);
    1e2c:	2005      	movs	r0, #5
	#endif

  	ISR_EXIT;																// Procedimento para saida da interrupção
}
    1e2e:	e8bd 41f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, lr}
	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART0);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART0);
    1e32:	f7ff bde1 	b.w	19f8 <nvic_clearPendingIRQ>
    1e36:	bf00      	nop
    1e38:	4000c008 	.word	0x4000c008
    1e3c:	4000c014 	.word	0x4000c014
    1e40:	4000c004 	.word	0x4000c004
    1e44:	100006a4 	.word	0x100006a4
    1e48:	100006a8 	.word	0x100006a8
    1e4c:	4000c000 	.word	0x4000c000
    1e50:	100006b4 	.word	0x100006b4
    1e54:	100006a2 	.word	0x100006a2

Disassembly of section .text.uart1_SetBaudrate:

00001e58 <uart1_SetBaudrate>:
		}
	}
	return r;
}

void uart1_SetBaudrate(u32 baudrate) {
    1e58:	e92d 4ff7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    1e5c:	4680      	mov	r8, r0
  	U1LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1e5e:	4e34      	ldr	r6, [pc, #208]	; (1f30 <uart1_SetBaudrate+0xd8>)
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1e60:	4834      	ldr	r0, [pc, #208]	; (1f34 <uart1_SetBaudrate+0xdc>)
	}
	return r;
}

void uart1_SetBaudrate(u32 baudrate) {
  	U1LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    1e62:	2380      	movs	r3, #128	; 0x80
    1e64:	6033      	str	r3, [r6, #0]
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1e66:	fb90 f0f8 	sdiv	r0, r0, r8
    1e6a:	f7fe fb99 	bl	5a0 <__aeabi_i2d>
    1e6e:	a32c      	add	r3, pc, #176	; (adr r3, 1f20 <uart1_SetBaudrate+0xc8>)
    1e70:	e9d3 2300 	ldrd	r2, r3, [r3]
    1e74:	f7fe fbfa 	bl	66c <__aeabi_dmul>
    1e78:	f7fe fe92 	bl	ba0 <__aeabi_d2iz>
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
    1e7c:	46c2      	mov	sl, r8
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    1e7e:	4607      	mov	r7, r0

void uart1_SetBaudrate(u32 baudrate) {
  	U1LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U1DLL = f_div%256;        									// Ajusta o baudrate byte baixo
    1e80:	4b2d      	ldr	r3, [pc, #180]	; (1f38 <uart1_SetBaudrate+0xe0>)
    1e82:	b2c2      	uxtb	r2, r0
    1e84:	601a      	str	r2, [r3, #0]
  	U1DLM = f_div/256;    										// Ajusta o baudrate byte alto
    1e86:	0a02      	lsrs	r2, r0, #8
    1e88:	605a      	str	r2, [r3, #4]
//	fraction = BAUD*(1+D/M)
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
    1e8a:	f04f 0910 	mov.w	r9, #16
	e = baud;
	for(m=1;m<=15;m++) {
    1e8e:	2401      	movs	r4, #1
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
				e = abs(baud-b);
				r = (m<<4) + d;
    1e90:	ea4f 1b04 	mov.w	fp, r4, lsl #4
    1e94:	2500      	movs	r5, #0
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1e96:	4628      	mov	r0, r5
    1e98:	f7fe ff64 	bl	d64 <__aeabi_i2f>
    1e9c:	9001      	str	r0, [sp, #4]
    1e9e:	4620      	mov	r0, r4
    1ea0:	f7fe ff60 	bl	d64 <__aeabi_i2f>
    1ea4:	9b01      	ldr	r3, [sp, #4]
    1ea6:	4601      	mov	r1, r0
    1ea8:	4618      	mov	r0, r3
    1eaa:	f7ff f863 	bl	f74 <__aeabi_fdiv>
    1eae:	f04f 517e 	mov.w	r1, #1065353216	; 0x3f800000
    1eb2:	f7fe fea3 	bl	bfc <__addsf3>
    1eb6:	9001      	str	r0, [sp, #4]
    1eb8:	4638      	mov	r0, r7
    1eba:	f7fe ff53 	bl	d64 <__aeabi_i2f>
    1ebe:	9b01      	ldr	r3, [sp, #4]
    1ec0:	4601      	mov	r1, r0
    1ec2:	4618      	mov	r0, r3
    1ec4:	f7fe ffa2 	bl	e0c <__aeabi_fmul>
    1ec8:	f7fe fb7c 	bl	5c4 <__aeabi_f2d>
    1ecc:	2200      	movs	r2, #0
    1ece:	4b1b      	ldr	r3, [pc, #108]	; (1f3c <uart1_SetBaudrate+0xe4>)
    1ed0:	f7fe fbcc 	bl	66c <__aeabi_dmul>
    1ed4:	4602      	mov	r2, r0
    1ed6:	460b      	mov	r3, r1
    1ed8:	a113      	add	r1, pc, #76	; (adr r1, 1f28 <uart1_SetBaudrate+0xd0>)
    1eda:	e9d1 0100 	ldrd	r0, r1, [r1]
    1ede:	f7fe fcef 	bl	8c0 <__aeabi_ddiv>
    1ee2:	f7fe fe5d 	bl	ba0 <__aeabi_d2iz>
    1ee6:	ebc0 0008 	rsb	r0, r0, r8
    1eea:	2800      	cmp	r0, #0
    1eec:	bfb8      	it	lt
    1eee:	4240      	neglt	r0, r0
    1ef0:	4550      	cmp	r0, sl
    1ef2:	bfb8      	it	lt
    1ef4:	eb05 090b 	addlt.w	r9, r5, fp
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1ef8:	f105 0501 	add.w	r5, r5, #1
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    1efc:	bfb8      	it	lt
    1efe:	4682      	movlt	sl, r0
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    1f00:	42ac      	cmp	r4, r5
    1f02:	d1c8      	bne.n	1e96 <uart1_SetBaudrate+0x3e>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
    1f04:	3401      	adds	r4, #1
    1f06:	2c10      	cmp	r4, #16
    1f08:	d1c2      	bne.n	1e90 <uart1_SetBaudrate+0x38>
  	U1LCR = U1LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U1DLL = f_div%256;        									// Ajusta o baudrate byte baixo
  	U1DLM = f_div/256;    										// Ajusta o baudrate byte alto
  	U1FDR = uart_fdr(baudrate);
    1f0a:	4b0d      	ldr	r3, [pc, #52]	; (1f40 <uart1_SetBaudrate+0xe8>)
    1f0c:	f8c3 9000 	str.w	r9, [r3]
	U1LCR = (UART1_MODE & ~U1LCR_DLAB_ENABLE);					// Configura o modo de trabalho da uart e desativa o acesso aos registradores do baudrate
    1f10:	2303      	movs	r3, #3
    1f12:	6033      	str	r3, [r6, #0]
}
    1f14:	b003      	add	sp, #12
    1f16:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
    1f1a:	bf00      	nop
    1f1c:	f3af 8000 	nop.w
    1f20:	9999999a 	.word	0x9999999a
    1f24:	3fe99999 	.word	0x3fe99999
    1f28:	00000000 	.word	0x00000000
    1f2c:	4177d784 	.word	0x4177d784
    1f30:	4001000c 	.word	0x4001000c
    1f34:	0017d784 	.word	0x0017d784
    1f38:	40010000 	.word	0x40010000
    1f3c:	40300000 	.word	0x40300000
    1f40:	40010028 	.word	0x40010028

Disassembly of section .text.uart1_Init:

00001f44 <uart1_Init>:
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart1_Init(u32 baudrate) {
  	PCONP |= PCUART1;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1f44:	4a23      	ldr	r2, [pc, #140]	; (1fd4 <uart1_Init+0x90>)
// Descrição: 	Incializa e configura o modo de trabalho da UART
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart1_Init(u32 baudrate) {
    1f46:	e92d 43f8 	stmdb	sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
  	PCONP |= PCUART1;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1f4a:	6813      	ldr	r3, [r2, #0]
	U1_CTS_DIR &= ~U1_CTS; 				// Pino CTS como entrada
	U1_RTS_DIR |= U1_RTS; 				// Pino RTS como saída
	uart1_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U1IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1f4c:	4c22      	ldr	r4, [pc, #136]	; (1fd8 <uart1_Init+0x94>)
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart1_Init(u32 baudrate) {
  	PCONP |= PCUART1;											// Ligar a uart no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    1f4e:	f043 0310 	orr.w	r3, r3, #16
    1f52:	6013      	str	r3, [r2, #0]
  		U1_PINSEL1 = (U1_PINSEL1 & ~U1_PINMASK1) | U1_PINS1;	// Configura os pinos do uC para a função UART.
  	#endif
	#endif // arm7tdmi

  	#if defined(cortexm3)
	uart1_ConfigPort();
    1f54:	4a21      	ldr	r2, [pc, #132]	; (1fdc <uart1_Init+0x98>)
	U1_RTS_DIR |= U1_RTS; 				// Pino RTS como saída
	uart1_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U1IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
  	U1IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1f56:	4d22      	ldr	r5, [pc, #136]	; (1fe0 <uart1_Init+0x9c>)
  		U1_PINSEL1 = (U1_PINSEL1 & ~U1_PINMASK1) | U1_PINS1;	// Configura os pinos do uC para a função UART.
  	#endif
	#endif // arm7tdmi

  	#if defined(cortexm3)
	uart1_ConfigPort();
    1f58:	6813      	ldr	r3, [r2, #0]
	U1_CTS_DIR &= ~U1_CTS; 				// Pino CTS como entrada
	U1_RTS_DIR |= U1_RTS; 				// Pino RTS como saída
	uart1_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U1IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1f5a:	2600      	movs	r6, #0
  		U1_PINSEL1 = (U1_PINSEL1 & ~U1_PINMASK1) | U1_PINS1;	// Configura os pinos do uC para a função UART.
  	#endif
	#endif // arm7tdmi

  	#if defined(cortexm3)
	uart1_ConfigPort();
    1f5c:	f043 4380 	orr.w	r3, r3, #1073741824	; 0x40000000
    1f60:	6013      	str	r3, [r2, #0]
    1f62:	6853      	ldr	r3, [r2, #4]
	uart1_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U1IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
  	U1IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
  	U1FCR = (U1FCR_TX_FIFO_RESET | U1FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
    1f64:	2706      	movs	r7, #6
  		U1_PINSEL1 = (U1_PINSEL1 & ~U1_PINMASK1) | U1_PINS1;	// Configura os pinos do uC para a função UART.
  	#endif
	#endif // arm7tdmi

  	#if defined(cortexm3)
	uart1_ConfigPort();
    1f66:	f043 0301 	orr.w	r3, r3, #1
    1f6a:	6053      	str	r3, [r2, #4]
	U1_CTS_DIR &= ~U1_CTS; 				// Pino CTS como entrada
	U1_RTS_DIR |= U1_RTS; 				// Pino RTS como saída
	uart1_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U1IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    1f6c:	6026      	str	r6, [r4, #0]
  	U1IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    1f6e:	682b      	ldr	r3, [r5, #0]
  	U1FCR = (U1FCR_TX_FIFO_RESET | U1FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
    1f70:	602f      	str	r7, [r5, #0]
  	
  	uart1_SetBaudrate(baudrate);
    1f72:	f7ff ff71 	bl	1e58 <uart1_SetBaudrate>
  	
  	U1FCR = UART1_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1f76:	f04f 0801 	mov.w	r8, #1

	U1RBR;                                						// Limpa o registrador de recepçao de dados
    1f7a:	4b1a      	ldr	r3, [pc, #104]	; (1fe4 <uart1_Init+0xa0>)
  	U1IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
  	U1FCR = (U1FCR_TX_FIFO_RESET | U1FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
  	
  	uart1_SetBaudrate(baudrate);
  	
  	U1FCR = UART1_FIFOMODE;										// Configura o modo de trabalho da FIFO
    1f7c:	f8c5 8000 	str.w	r8, [r5]

	U1RBR;                                						// Limpa o registrador de recepçao de dados
    1f80:	681b      	ldr	r3, [r3, #0]
  	U1LSR;                                						// Limpa o registrador de estado de linha
    1f82:	4b19      	ldr	r3, [pc, #100]	; (1fe8 <uart1_Init+0xa4>)
	U1FCR = U1FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
    1f84:	f04f 0902 	mov.w	r9, #2
  	uart1_SetBaudrate(baudrate);
  	
  	U1FCR = UART1_FIFOMODE;										// Configura o modo de trabalho da FIFO

	U1RBR;                                						// Limpa o registrador de recepçao de dados
  	U1LSR;                                						// Limpa o registrador de estado de linha
    1f88:	681b      	ldr	r3, [r3, #0]
	U1FCR = U1FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
  	U1FCR = U1FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    1f8a:	2304      	movs	r3, #4
  	
  	U1FCR = UART1_FIFOMODE;										// Configura o modo de trabalho da FIFO

	U1RBR;                                						// Limpa o registrador de recepçao de dados
  	U1LSR;                                						// Limpa o registrador de estado de linha
	U1FCR = U1FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
    1f8c:	f8c5 9000 	str.w	r9, [r5]
  	if (!irq_Install(VIC_UART1, uart1_ISR, UART1_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART1);
    1f90:	4638      	mov	r0, r7
  	U1FCR = UART1_FIFOMODE;										// Configura o modo de trabalho da FIFO

	U1RBR;                                						// Limpa o registrador de recepçao de dados
  	U1LSR;                                						// Limpa o registrador de estado de linha
	U1FCR = U1FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
  	U1FCR = U1FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    1f92:	602b      	str	r3, [r5, #0]
  	if (!irq_Install(VIC_UART1, uart1_ISR, UART1_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART1);
    1f94:	f7ff fd2d 	bl	19f2 <nvic_enableIRQ>
	nvic_setPriority(VIC_UART1, UART1_PRIO_LEVEL);
    1f98:	4649      	mov	r1, r9
    1f9a:	4638      	mov	r0, r7
    1f9c:	f7ff fd38 	bl	1a10 <nvic_setPriority>
	#if (USE_MALLOC == pdON)
	u1_data_rx = malloc(UART1_RX_BUFFER_SIZE*sizeof(u8));
	u1_data_tx = malloc(UART1_TX_BUFFER_SIZE*sizeof(u8));
	#endif

	buffer_Init(&u1_buf_rx, u1_data_rx, UART1_RX_BUFFER_SIZE);
    1fa0:	2296      	movs	r2, #150	; 0x96
    1fa2:	4912      	ldr	r1, [pc, #72]	; (1fec <uart1_Init+0xa8>)
    1fa4:	4812      	ldr	r0, [pc, #72]	; (1ff0 <uart1_Init+0xac>)
    1fa6:	f001 ff7d 	bl	3ea4 <buffer_Init>
	buffer_Init(&u1_buf_tx, u1_data_tx, UART1_TX_BUFFER_SIZE);
    1faa:	2296      	movs	r2, #150	; 0x96
    1fac:	4911      	ldr	r1, [pc, #68]	; (1ff4 <uart1_Init+0xb0>)
    1fae:	4812      	ldr	r0, [pc, #72]	; (1ff8 <uart1_Init+0xb4>)
    1fb0:	f001 ff78 	bl	3ea4 <buffer_Init>
		
	u1_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1fb4:	4b11      	ldr	r3, [pc, #68]	; (1ffc <uart1_Init+0xb8>)
		
	U1IER |= U1IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
	U1IER &= ~U1IER_ETBEI;               						// Desabilita a interrupção de buffer vazio de transmissão
	
	return pdPASS;
}
    1fb6:	4640      	mov	r0, r8
	#endif

	buffer_Init(&u1_buf_rx, u1_data_rx, UART1_RX_BUFFER_SIZE);
	buffer_Init(&u1_buf_tx, u1_data_tx, UART1_TX_BUFFER_SIZE);
		
	u1_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    1fb8:	801e      	strh	r6, [r3, #0]
	u1_tx_running = pdFALSE;
    1fba:	4b11      	ldr	r3, [pc, #68]	; (2000 <uart1_Init+0xbc>)
    1fbc:	701e      	strb	r6, [r3, #0]
		
	U1IER |= U1IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    1fbe:	6823      	ldr	r3, [r4, #0]
    1fc0:	ea43 0308 	orr.w	r3, r3, r8
    1fc4:	6023      	str	r3, [r4, #0]
	U1IER &= ~U1IER_ETBEI;               						// Desabilita a interrupção de buffer vazio de transmissão
    1fc6:	6823      	ldr	r3, [r4, #0]
    1fc8:	f023 0302 	bic.w	r3, r3, #2
    1fcc:	6023      	str	r3, [r4, #0]
	
	return pdPASS;
}
    1fce:	e8bd 83f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
    1fd2:	bf00      	nop
    1fd4:	400fc0c4 	.word	0x400fc0c4
    1fd8:	40010004 	.word	0x40010004
    1fdc:	4002c000 	.word	0x4002c000
    1fe0:	40010008 	.word	0x40010008
    1fe4:	40010000 	.word	0x40010000
    1fe8:	40010014 	.word	0x40010014
    1fec:	1000075a 	.word	0x1000075a
    1ff0:	100007f0 	.word	0x100007f0
    1ff4:	100007fc 	.word	0x100007fc
    1ff8:	10000894 	.word	0x10000894
    1ffc:	10000758 	.word	0x10000758
    2000:	10000756 	.word	0x10000756

Disassembly of section .text.uart1_GetChar:

00002004 <uart1_GetChar>:
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Captura o próximo byte recebido na UART
// Parametros: 	Ponteiro para da variavel char para o retorno do byte recebido
// Retorna:		pdPASS indicando que existe caractere recebido ou o código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart1_GetChar(u8 *ch) {
    2004:	b538      	push	{r3, r4, r5, lr}
    2006:	4605      	mov	r5, r0
	int ret;

	if ( u1_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
    2008:	480d      	ldr	r0, [pc, #52]	; (2040 <uart1_GetChar+0x3c>)
    200a:	8883      	ldrh	r3, [r0, #4]
    200c:	b29b      	uxth	r3, r3
    200e:	b18b      	cbz	r3, 2034 <uart1_GetChar+0x30>
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro

	if ( u1_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
    2010:	88c3      	ldrh	r3, [r0, #6]
    2012:	b29b      	uxth	r3, r3
    2014:	b18b      	cbz	r3, 203a <uart1_GetChar+0x36>
		U1IER &= ~U1IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    2016:	4c0b      	ldr	r4, [pc, #44]	; (2044 <uart1_GetChar+0x40>)
    2018:	6823      	ldr	r3, [r4, #0]
    201a:	f023 0301 	bic.w	r3, r3, #1
    201e:	6023      	str	r3, [r4, #0]
		nop();
    2020:	bf00      	nop
		*ch = buffer_GetFromFront(&u1_buf_rx);				// Captura os dados do inicio do buffer
    2022:	f001 ff45 	bl	3eb0 <buffer_GetFromFront>
    2026:	7028      	strb	r0, [r5, #0]
		U1IER |= U1IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    2028:	6823      	ldr	r3, [r4, #0]
		ret = pdPASS;
    202a:	2001      	movs	r0, #1

	if ( u1_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
		U1IER &= ~U1IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		nop();
		*ch = buffer_GetFromFront(&u1_buf_rx);				// Captura os dados do inicio do buffer
		U1IER |= U1IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    202c:	f043 0301 	orr.w	r3, r3, #1
    2030:	6023      	str	r3, [r4, #0]
    2032:	bd38      	pop	{r3, r4, r5, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart1_GetChar(u8 *ch) {
	int ret;

	if ( u1_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro
    2034:	f06f 000b 	mvn.w	r0, #11
    2038:	bd38      	pop	{r3, r4, r5, pc}
		nop();
		*ch = buffer_GetFromFront(&u1_buf_rx);				// Captura os dados do inicio do buffer
		U1IER |= U1IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		ret = pdPASS;
	} else
		ret = errBUFFER_EMPTY;
    203a:	f06f 000a 	mvn.w	r0, #10

	return ret;
}
    203e:	bd38      	pop	{r3, r4, r5, pc}
    2040:	100007f0 	.word	0x100007f0
    2044:	40010004 	.word	0x40010004

Disassembly of section .text.uart1_ClearBufferRx:

00002048 <uart1_ClearBufferRx>:
// -----------------------------------------------------------------------------------------------------------------
// Descrição: 	Limpa o buffer e FIFO de recepção
// Parametros:	Nenhum
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------------------------
void uart1_ClearBufferRx(void) {
    2048:	b510      	push	{r4, lr}
	U1IER &= ~U1IER_ERBFI;				// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    204a:	4c0a      	ldr	r4, [pc, #40]	; (2074 <uart1_ClearBufferRx+0x2c>)
    204c:	6823      	ldr	r3, [r4, #0]
    204e:	f023 0301 	bic.w	r3, r3, #1
    2052:	6023      	str	r3, [r4, #0]
	nop();
    2054:	bf00      	nop
	u1_overflow_rx = 0; 				// Limpa overflow do buffer de recepção
    2056:	4b08      	ldr	r3, [pc, #32]	; (2078 <uart1_ClearBufferRx+0x30>)
    2058:	2200      	movs	r2, #0
    205a:	801a      	strh	r2, [r3, #0]
	U1FCR = U1FCR_RX_FIFO_RESET;		// Limpa RX FIFO
    205c:	4b07      	ldr	r3, [pc, #28]	; (207c <uart1_ClearBufferRx+0x34>)
    205e:	2202      	movs	r2, #2
    2060:	601a      	str	r2, [r3, #0]
	buffer_Clear(&u1_buf_rx);			// Limpa o buffer de recepção
    2062:	4807      	ldr	r0, [pc, #28]	; (2080 <uart1_ClearBufferRx+0x38>)
    2064:	f001 ff69 	bl	3f3a <buffer_Clear>
	U1IER |= U1IER_ERBFI;				// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    2068:	6823      	ldr	r3, [r4, #0]
    206a:	f043 0301 	orr.w	r3, r3, #1
    206e:	6023      	str	r3, [r4, #0]
    2070:	bd10      	pop	{r4, pc}
    2072:	bf00      	nop
    2074:	40010004 	.word	0x40010004
    2078:	10000758 	.word	0x10000758
    207c:	40010008 	.word	0x40010008
    2080:	100007f0 	.word	0x100007f0

Disassembly of section .text.uart1_PutChar:

00002084 <uart1_PutChar>:
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart1_PutChar(n16 ch) {
	int sts;

	if ( u1_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    2084:	4b15      	ldr	r3, [pc, #84]	; (20dc <uart1_PutChar+0x58>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Coloca um caractere na fila de transmissão
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart1_PutChar(n16 ch) {
    2086:	b570      	push	{r4, r5, r6, lr}
	int sts;

	if ( u1_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    2088:	889b      	ldrh	r3, [r3, #4]
    208a:	b29b      	uxth	r3, r3
    208c:	b303      	cbz	r3, 20d0 <uart1_PutChar+0x4c>
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U1IER &= ~U1IER_ETBEI;                 								// Desativa a interrupção de transmissão
    208e:	4c14      	ldr	r4, [pc, #80]	; (20e0 <uart1_PutChar+0x5c>)
		nop();
		sts = buffer_AddToEnd(&u1_buf_tx, ch);
    2090:	b2c5      	uxtb	r5, r0
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U1IER &= ~U1IER_ETBEI;                 								// Desativa a interrupção de transmissão
    2092:	6823      	ldr	r3, [r4, #0]
    2094:	4e12      	ldr	r6, [pc, #72]	; (20e0 <uart1_PutChar+0x5c>)
    2096:	f023 0302 	bic.w	r3, r3, #2
    209a:	6023      	str	r3, [r4, #0]
		nop();
    209c:	bf00      	nop
		sts = buffer_AddToEnd(&u1_buf_tx, ch);
    209e:	480f      	ldr	r0, [pc, #60]	; (20dc <uart1_PutChar+0x58>)
    20a0:	4629      	mov	r1, r5
    20a2:	f001 ff27 	bl	3ef4 <buffer_AddToEnd>
		U1IER |= U1IER_ETBEI;                  								// Habilita a interrupção de transmissão
    20a6:	6823      	ldr	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    20a8:	300a      	adds	r0, #10

	do {
		U1IER &= ~U1IER_ETBEI;                 								// Desativa a interrupção de transmissão
		nop();
		sts = buffer_AddToEnd(&u1_buf_tx, ch);
		U1IER |= U1IER_ETBEI;                  								// Habilita a interrupção de transmissão
    20aa:	f043 0302 	orr.w	r3, r3, #2
    20ae:	6023      	str	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    20b0:	d0ef      	beq.n	2092 <uart1_PutChar+0xe>

	if (!u1_tx_running) {													// Checa se existe dado sendo transmitido
    20b2:	4c0c      	ldr	r4, [pc, #48]	; (20e4 <uart1_PutChar+0x60>)
    20b4:	7823      	ldrb	r3, [r4, #0]
    20b6:	b973      	cbnz	r3, 20d6 <uart1_PutChar+0x52>
  		U1THR = buffer_GetFromFront(&u1_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
    20b8:	4808      	ldr	r0, [pc, #32]	; (20dc <uart1_PutChar+0x58>)
    20ba:	f001 fef9 	bl	3eb0 <buffer_GetFromFront>
    20be:	4b0a      	ldr	r3, [pc, #40]	; (20e8 <uart1_PutChar+0x64>)
    20c0:	6018      	str	r0, [r3, #0]
  		u1_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
    20c2:	2001      	movs	r0, #1
    20c4:	7020      	strb	r0, [r4, #0]
  		U1IER |= U1IER_ETBEI;                  								// Habilita a interrupção de transmissão
    20c6:	6833      	ldr	r3, [r6, #0]
    20c8:	f043 0302 	orr.w	r3, r3, #2
    20cc:	6033      	str	r3, [r6, #0]
    20ce:	bd70      	pop	{r4, r5, r6, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart1_PutChar(n16 ch) {
	int sts;

	if ( u1_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
   		return errBUFFER_NO_EXIST;                          				// Retorna indicando erro
    20d0:	f06f 000b 	mvn.w	r0, #11
    20d4:	bd70      	pop	{r4, r5, r6, pc}
  		U1THR = buffer_GetFromFront(&u1_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
  		u1_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
  		U1IER |= U1IER_ETBEI;                  								// Habilita a interrupção de transmissão
   	}

  	return pdPASS;
    20d6:	2001      	movs	r0, #1
}
    20d8:	bd70      	pop	{r4, r5, r6, pc}
    20da:	bf00      	nop
    20dc:	10000894 	.word	0x10000894
    20e0:	40010004 	.word	0x40010004
    20e4:	10000756 	.word	0x10000756
    20e8:	40010000 	.word	0x40010000

Disassembly of section .text.uart1_SpaceTx:

000020ec <uart1_SpaceTx>:
// Retorna:		O tamanho em bytes do espaço disponivel para transmissão
// -------------------------------------------------------------------------------------------------------------------
u16 uart1_SpaceTx(void) {
	u16 qtd;
	
	U1IER &= ~U1IER_ETBEI;                 								// Desativa a interrupção de transmissão
    20ec:	4b07      	ldr	r3, [pc, #28]	; (210c <uart1_SpaceTx+0x20>)
    20ee:	681a      	ldr	r2, [r3, #0]
    20f0:	f022 0202 	bic.w	r2, r2, #2
    20f4:	601a      	str	r2, [r3, #0]
	nop();
    20f6:	bf00      	nop
	qtd = (u16)(u1_buf_tx.size - u1_buf_tx.datalength);					// Retorna com o espaço disponivel
    20f8:	4905      	ldr	r1, [pc, #20]	; (2110 <uart1_SpaceTx+0x24>)
    20fa:	888a      	ldrh	r2, [r1, #4]
    20fc:	88c8      	ldrh	r0, [r1, #6]
	U1IER |= U1IER_ETBEI;                  								// Habilita a interrupção de transmissão
    20fe:	6819      	ldr	r1, [r3, #0]
	return qtd;
    2100:	1a10      	subs	r0, r2, r0
	u16 qtd;
	
	U1IER &= ~U1IER_ETBEI;                 								// Desativa a interrupção de transmissão
	nop();
	qtd = (u16)(u1_buf_tx.size - u1_buf_tx.datalength);					// Retorna com o espaço disponivel
	U1IER |= U1IER_ETBEI;                  								// Habilita a interrupção de transmissão
    2102:	f041 0102 	orr.w	r1, r1, #2
    2106:	6019      	str	r1, [r3, #0]
	return qtd;
}
    2108:	b280      	uxth	r0, r0
    210a:	4770      	bx	lr
    210c:	40010004 	.word	0x40010004
    2110:	10000894 	.word	0x10000894

Disassembly of section .text.uart1_EmptyTx:

00002114 <uart1_EmptyTx>:
// Parametros: 	Nenhum
// Retorna:		pdFALSE = Se o registradores U0THR ou U0TSR não estão vazios
//				pdTRUE = Se o registradores U0THR ou U0TSR estão vazios
// -------------------------------------------------------------------------------------------------------------------
int uart1_EmptyTx(void) {
  	if ((U1LSR & (U1LSR_THRE | U1LSR_TEMT)) == (U1LSR_THRE | U1LSR_TEMT))
    2114:	4b04      	ldr	r3, [pc, #16]	; (2128 <uart1_EmptyTx+0x14>)
    2116:	6818      	ldr	r0, [r3, #0]
    2118:	f000 0060 	and.w	r0, r0, #96	; 0x60
  			return pdTRUE;
  	else	return pdFALSE;
}
    211c:	f1a0 0360 	sub.w	r3, r0, #96	; 0x60
    2120:	4258      	negs	r0, r3
    2122:	4158      	adcs	r0, r3
    2124:	4770      	bx	lr
    2126:	bf00      	nop
    2128:	40010014 	.word	0x40010014

Disassembly of section .text.uart1_WriteTx:

0000212c <uart1_WriteTx>:
// Descrição:	Adiociona N caracteres no buffer de transmissão
// Parametros: 	Ponteiro do buffer 
//				Quantidade de caracteres as serem transmitidos
// Retorna:		pdPASS = Transmitido com sucesso ou o código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart1_WriteTx(u8 *buffer, u16 count) {
    212c:	b538      	push	{r3, r4, r5, lr}
    212e:	460c      	mov	r4, r1
    2130:	4605      	mov	r5, r0
	if (count > uart1_SpaceTx())									// Checa se exste espaço suficiente no buffer de TX de espaço insuficiente
    2132:	f7ff ffdb 	bl	20ec <uart1_SpaceTx>
    2136:	42a0      	cmp	r0, r4
    2138:	d20a      	bcs.n	2150 <uart1_WriteTx+0x24>
   		return errBUFFER_FULL;										// Retorna cheio
    213a:	f06f 0009 	mvn.w	r0, #9
    213e:	bd38      	pop	{r3, r4, r5, pc}
  	
  	while (count && (uart1_PutChar(*buffer++) >= 0))				// Faça enquanto tem dados a serem transmitidos
    2140:	f815 0b01 	ldrb.w	r0, [r5], #1
    2144:	f7ff ff9e 	bl	2084 <uart1_PutChar>
    2148:	2800      	cmp	r0, #0
    214a:	dbf6      	blt.n	213a <uart1_WriteTx+0xe>
    	count--;
    214c:	3c01      	subs	r4, #1
    214e:	b2a4      	uxth	r4, r4
// -------------------------------------------------------------------------------------------------------------------
int uart1_WriteTx(u8 *buffer, u16 count) {
	if (count > uart1_SpaceTx())									// Checa se exste espaço suficiente no buffer de TX de espaço insuficiente
   		return errBUFFER_FULL;										// Retorna cheio
  	
  	while (count && (uart1_PutChar(*buffer++) >= 0))				// Faça enquanto tem dados a serem transmitidos
    2150:	2c00      	cmp	r4, #0
    2152:	d1f5      	bne.n	2140 <uart1_WriteTx+0x14>
    	count--;

  	return (count ? errBUFFER_FULL : pdPASS); 						// Se count = 0 retorna 0 (Sucesso) senão retorna -2 (erro)
    2154:	2001      	movs	r0, #1
}
    2156:	bd38      	pop	{r3, r4, r5, pc}

Disassembly of section .text.uart1_ISR:

00002158 <uart1_ISR>:
//###################################################################################################################
// UART SERVIÇO DE INTERRUPÇÕES
// 		Descrição: 	Esta função implementa o ISR da UART1
//###################################################################################################################
//###################################################################################################################
void uart1_ISR (void) {
    2158:	b570      	push	{r4, r5, r6, lr}
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;

  	while ( !((int_flags = U1IIR) & U1IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART
    215a:	4d23      	ldr	r5, [pc, #140]	; (21e8 <uart1_ISR+0x90>)
      	case U1IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U1IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
     		do { 
      			if (buffer_AddToEnd(&u1_buf_rx, U1RBR) == errBUFFER_FULL)
					u1_overflow_rx++;
      		} while(U1LSR & U1LSR_RDR);										// Faça enquanto existe dados validos na FIFO de recepção
    215c:	4c23      	ldr	r4, [pc, #140]	; (21ec <uart1_ISR+0x94>)
void uart1_ISR (void) {
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;

  	while ( !((int_flags = U1IIR) & U1IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART
    215e:	682b      	ldr	r3, [r5, #0]
    2160:	b2db      	uxtb	r3, r3
    2162:	07da      	lsls	r2, r3, #31
    2164:	d43b      	bmi.n	21de <uart1_ISR+0x86>
    	switch (int_flags & U1IIR_ID_MASK) {									// Identifica a fonte de interrupção
    2166:	f003 030e 	and.w	r3, r3, #14
    216a:	2b0c      	cmp	r3, #12
    216c:	d831      	bhi.n	21d2 <uart1_ISR+0x7a>
    216e:	e8df f003 	tbb	[pc, r3]
    2172:	3033      	.short	0x3033
    2174:	3009301a 	.word	0x3009301a
    2178:	30303007 	.word	0x30303007
    217c:	3030      	.short	0x3030
    217e:	09          	.byte	0x09
    217f:	00          	.byte	0x00
    	case U1IIR_RLS_INT:                									// Caso recebeu uma INT de erro na linha de recepção (receive line status)
        	U1LSR;                         									// Limpa registrador de status de linha
    2180:	6823      	ldr	r3, [r4, #0]
        	break;
    2182:	e7ec      	b.n	215e <uart1_ISR+0x6>
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U1IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U1IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
     		do { 
      			if (buffer_AddToEnd(&u1_buf_rx, U1RBR) == errBUFFER_FULL)
    2184:	4e1a      	ldr	r6, [pc, #104]	; (21f0 <uart1_ISR+0x98>)
    2186:	6831      	ldr	r1, [r6, #0]
    2188:	481a      	ldr	r0, [pc, #104]	; (21f4 <uart1_ISR+0x9c>)
    218a:	b2c9      	uxtb	r1, r1
    218c:	f001 feb2 	bl	3ef4 <buffer_AddToEnd>
    2190:	300a      	adds	r0, #10
    2192:	d104      	bne.n	219e <uart1_ISR+0x46>
					u1_overflow_rx++;
    2194:	4a18      	ldr	r2, [pc, #96]	; (21f8 <uart1_ISR+0xa0>)
    2196:	8813      	ldrh	r3, [r2, #0]
    2198:	3301      	adds	r3, #1
    219a:	b29b      	uxth	r3, r3
    219c:	8013      	strh	r3, [r2, #0]
      		} while(U1LSR & U1LSR_RDR);										// Faça enquanto existe dados validos na FIFO de recepção
    219e:	6823      	ldr	r3, [r4, #0]
    21a0:	07d8      	lsls	r0, r3, #31
    21a2:	d4f0      	bmi.n	2186 <uart1_ISR+0x2e>
    21a4:	e7db      	b.n	215e <uart1_ISR+0x6>
         			break;
        		} else {
					#if (UART1_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart1_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif     			
        				U1THR = buffer_GetFromFront(&u1_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    21a6:	4e12      	ldr	r6, [pc, #72]	; (21f0 <uart1_ISR+0x98>)

     	// RETIRA OS DADOS DO BUFFER TX PARA A FIFO DE TRANSMISSÃO
     		// Essa interrupção é gerada quando a FIFO de transmissão de 16 bytes está vazia
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
      	case U1IIR_THRE_INT:              									// Interrupção da FIFO de 16 bytes quando está vazia
        	while (U1LSR & U1LSR_THRE) {									// Faça enquanto há espaço na FIFO
    21a8:	6823      	ldr	r3, [r4, #0]
    21aa:	0699      	lsls	r1, r3, #26
    21ac:	d5d7      	bpl.n	215e <uart1_ISR+0x6>
        		if (buffer_IsEmpty(&u1_buf_tx) ) {						 	// Checa se o buffer de transmissão já está vazio
    21ae:	4813      	ldr	r0, [pc, #76]	; (21fc <uart1_ISR+0xa4>)
    21b0:	f001 febd 	bl	3f2e <buffer_IsEmpty>
    21b4:	b140      	cbz	r0, 21c8 <uart1_ISR+0x70>
        			u1_tx_running = pdFALSE;   								// Sinaliza que não existe dados para trasnmissao
    21b6:	4b12      	ldr	r3, [pc, #72]	; (2200 <uart1_ISR+0xa8>)
    21b8:	2200      	movs	r2, #0
    21ba:	701a      	strb	r2, [r3, #0]
        			U1IER &= ~U1IER_ETBEI;                					// Desativa a interrupção de transmissão
    21bc:	4a11      	ldr	r2, [pc, #68]	; (2204 <uart1_ISR+0xac>)
    21be:	6813      	ldr	r3, [r2, #0]
    21c0:	f023 0302 	bic.w	r3, r3, #2
    21c4:	6013      	str	r3, [r2, #0]
         			break;
    21c6:	e7ca      	b.n	215e <uart1_ISR+0x6>
        		} else {
					#if (UART1_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart1_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif     			
        				U1THR = buffer_GetFromFront(&u1_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    21c8:	480c      	ldr	r0, [pc, #48]	; (21fc <uart1_ISR+0xa4>)
    21ca:	f001 fe71 	bl	3eb0 <buffer_GetFromFront>
    21ce:	6030      	str	r0, [r6, #0]
    21d0:	e7ea      	b.n	21a8 <uart1_ISR+0x50>
      	case U1IIR_MS_INT:                 									// MODEM Status
        	U1MSR;                          								// Limpa o registrador de status do modem
        	break;

      	default:															// Interrupção desconhecida
        	U1LSR;															// Limpa registrador de status de linha
    21d2:	6823      	ldr	r3, [r4, #0]
        	U1RBR;															// Limpa o registrador de recepçao de dados
    21d4:	4b06      	ldr	r3, [pc, #24]	; (21f0 <uart1_ISR+0x98>)
    21d6:	681b      	ldr	r3, [r3, #0]
        	U1MSR;															// Limpa o registrador de status do modem
    21d8:	4b0b      	ldr	r3, [pc, #44]	; (2208 <uart1_ISR+0xb0>)
    21da:	681b      	ldr	r3, [r3, #0]
        	break;
    21dc:	e7bf      	b.n	215e <uart1_ISR+0x6>
  	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART1);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART1);
    21de:	2006      	movs	r0, #6
	#endif

  	ISR_EXIT;																// Procedimento para saida da interrupção
}
    21e0:	e8bd 4070 	ldmia.w	sp!, {r4, r5, r6, lr}
  	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART1);
	#endif
	#if defined (cortexm3)
	nvic_clearPendingIRQ(VIC_UART1);
    21e4:	f7ff bc08 	b.w	19f8 <nvic_clearPendingIRQ>
    21e8:	40010008 	.word	0x40010008
    21ec:	40010014 	.word	0x40010014
    21f0:	40010000 	.word	0x40010000
    21f4:	100007f0 	.word	0x100007f0
    21f8:	10000758 	.word	0x10000758
    21fc:	10000894 	.word	0x10000894
    2200:	10000756 	.word	0x10000756
    2204:	40010004 	.word	0x40010004
    2208:	40010018 	.word	0x40010018

Disassembly of section .text.uart3_SetBaudrate:

00002210 <uart3_SetBaudrate>:
		}
	}
	return r;
}

void uart3_SetBaudrate(u32 baudrate) {
    2210:	e92d 4ff7 	stmdb	sp!, {r0, r1, r2, r4, r5, r6, r7, r8, r9, sl, fp, lr}
    2214:	4680      	mov	r8, r0
  	U3LCR = U3LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    2216:	4e34      	ldr	r6, [pc, #208]	; (22e8 <uart3_SetBaudrate+0xd8>)
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    2218:	4834      	ldr	r0, [pc, #208]	; (22ec <uart3_SetBaudrate+0xdc>)
	}
	return r;
}

void uart3_SetBaudrate(u32 baudrate) {
  	U3LCR = U3LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
    221a:	2380      	movs	r3, #128	; 0x80
    221c:	6033      	str	r3, [r6, #0]
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    221e:	fb90 f0f8 	sdiv	r0, r0, r8
    2222:	f7fe f9bd 	bl	5a0 <__aeabi_i2d>
    2226:	a32c      	add	r3, pc, #176	; (adr r3, 22d8 <uart3_SetBaudrate+0xc8>)
    2228:	e9d3 2300 	ldrd	r2, r3, [r3]
    222c:	f7fe fa1e 	bl	66c <__aeabi_dmul>
    2230:	f7fe fcb6 	bl	ba0 <__aeabi_d2iz>
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
    2234:	46c2      	mov	sl, r8
//indiferente da frequência e do baud
//	detremina o valor dos registradores "DLM/DLL"
//	aqui forçamos o baud a ficar mais veloz do que o valor
//	desejado para que o ajuste através do FDR seja mais preciso
static int uart_dlm(int baud) {
	return (int)(((PCLK / 16) / baud) * 0.8);
    2236:	4607      	mov	r7, r0

void uart3_SetBaudrate(u32 baudrate) {
  	U3LCR = U3LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U3DLL = f_div%256;        								// Ajusta o baudrate byte baixo
    2238:	4b2d      	ldr	r3, [pc, #180]	; (22f0 <uart3_SetBaudrate+0xe0>)
    223a:	b2c2      	uxtb	r2, r0
    223c:	601a      	str	r2, [r3, #0]
  	U3DLM = f_div/256;    									// Ajusta o baudrate byte alto
    223e:	0a02      	lsrs	r2, r0, #8
    2240:	605a      	str	r2, [r3, #4]
//	fraction = BAUD*(1+D/M)
#include <stdlib.h>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
    2242:	f04f 0910 	mov.w	r9, #16
	e = baud;
	for(m=1;m<=15;m++) {
    2246:	2401      	movs	r4, #1
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
				e = abs(baud-b);
				r = (m<<4) + d;
    2248:	ea4f 1b04 	mov.w	fp, r4, lsl #4
    224c:	2500      	movs	r5, #0
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    224e:	4628      	mov	r0, r5
    2250:	f7fe fd88 	bl	d64 <__aeabi_i2f>
    2254:	9001      	str	r0, [sp, #4]
    2256:	4620      	mov	r0, r4
    2258:	f7fe fd84 	bl	d64 <__aeabi_i2f>
    225c:	9b01      	ldr	r3, [sp, #4]
    225e:	4601      	mov	r1, r0
    2260:	4618      	mov	r0, r3
    2262:	f7fe fe87 	bl	f74 <__aeabi_fdiv>
    2266:	f04f 517e 	mov.w	r1, #1065353216	; 0x3f800000
    226a:	f7fe fcc7 	bl	bfc <__addsf3>
    226e:	9001      	str	r0, [sp, #4]
    2270:	4638      	mov	r0, r7
    2272:	f7fe fd77 	bl	d64 <__aeabi_i2f>
    2276:	9b01      	ldr	r3, [sp, #4]
    2278:	4601      	mov	r1, r0
    227a:	4618      	mov	r0, r3
    227c:	f7fe fdc6 	bl	e0c <__aeabi_fmul>
    2280:	f7fe f9a0 	bl	5c4 <__aeabi_f2d>
    2284:	2200      	movs	r2, #0
    2286:	4b1b      	ldr	r3, [pc, #108]	; (22f4 <uart3_SetBaudrate+0xe4>)
    2288:	f7fe f9f0 	bl	66c <__aeabi_dmul>
    228c:	4602      	mov	r2, r0
    228e:	460b      	mov	r3, r1
    2290:	a113      	add	r1, pc, #76	; (adr r1, 22e0 <uart3_SetBaudrate+0xd0>)
    2292:	e9d1 0100 	ldrd	r0, r1, [r1]
    2296:	f7fe fb13 	bl	8c0 <__aeabi_ddiv>
    229a:	f7fe fc81 	bl	ba0 <__aeabi_d2iz>
    229e:	ebc0 0008 	rsb	r0, r0, r8
    22a2:	2800      	cmp	r0, #0
    22a4:	bfb8      	it	lt
    22a6:	4240      	neglt	r0, r0
    22a8:	4550      	cmp	r0, sl
    22aa:	bfb8      	it	lt
    22ac:	eb05 090b 	addlt.w	r9, r5, fp
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    22b0:	f105 0501 	add.w	r5, r5, #1
			//calcula o baud truncado
			b = uart_dlm(baud);
			//agora o valor final corrigido
			b = (int)(PCLK/(b*f*16.0));
			//erro ficou menor?
			if (abs(baud-b)<e) {
    22b4:	bfb8      	it	lt
    22b6:	4682      	movlt	sl, r0
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
		for (d=0;d<m;d++) {
    22b8:	42ac      	cmp	r4, r5
    22ba:	d1c8      	bne.n	224e <uart3_SetBaudrate+0x3e>
static int uart_fdr(int baud) {
	int d, m, b, e, r;
	float f;
	r = 1<<4; //apenas o MULVAL por default
	e = baud;
	for(m=1;m<=15;m++) {
    22bc:	3401      	adds	r4, #1
    22be:	2c10      	cmp	r4, #16
    22c0:	d1c2      	bne.n	2248 <uart3_SetBaudrate+0x38>
  	U3LCR = U3LCR_DLAB_ENABLE;             						// Seleciona os latches de devisões para ajusta do baudrate
  	u32 f_div = uart_dlm(baudrate);

  	U3DLL = f_div%256;        								// Ajusta o baudrate byte baixo
  	U3DLM = f_div/256;    									// Ajusta o baudrate byte alto
  	U3FDR = uart_fdr(baudrate);
    22c2:	4b0d      	ldr	r3, [pc, #52]	; (22f8 <uart3_SetBaudrate+0xe8>)
    22c4:	f8c3 9000 	str.w	r9, [r3]
	U3LCR = (UART3_MODE & ~U3LCR_DLAB_ENABLE);					// Configura o modo de trabalho da uart e desativa o acesso aos registradores do baudrate
    22c8:	2303      	movs	r3, #3
    22ca:	6033      	str	r3, [r6, #0]
}
    22cc:	b003      	add	sp, #12
    22ce:	e8bd 8ff0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
    22d2:	bf00      	nop
    22d4:	f3af 8000 	nop.w
    22d8:	9999999a 	.word	0x9999999a
    22dc:	3fe99999 	.word	0x3fe99999
    22e0:	00000000 	.word	0x00000000
    22e4:	4177d784 	.word	0x4177d784
    22e8:	4009c00c 	.word	0x4009c00c
    22ec:	0017d784 	.word	0x0017d784
    22f0:	4009c000 	.word	0x4009c000
    22f4:	40300000 	.word	0x40300000
    22f8:	4009c028 	.word	0x4009c028

Disassembly of section .text.uart3_Init:

000022fc <uart3_Init>:
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart3_Init(u32 baudrate) {
	PCONP |= PCUART3;											// Ligar a uart3 no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    22fc:	4a1d      	ldr	r2, [pc, #116]	; (2374 <uart3_Init+0x78>)
// Descrição: 	Incializa e configura o modo de trabalho da UART
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart3_Init(u32 baudrate) {
    22fe:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
	PCONP |= PCUART3;											// Ligar a uart3 no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    2300:	6813      	ldr	r3, [r2, #0]
	U3_CTS_DIR &= ~U3_CTS; 				// Pino CTS como entrada
	U3_RTS_DIR |= U3_RTS; 				// Pino RTS como saída
	uart3_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U3IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    2302:	4c1d      	ldr	r4, [pc, #116]	; (2378 <uart3_Init+0x7c>)
// Parametros:	baudrate: 
//					1200, 2400, ... , 57600, 115200 ...
// Retorna:		retorna pdPASS se iniciliazou sem problemas ou retorna código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart3_Init(u32 baudrate) {
	PCONP |= PCUART3;											// Ligar a uart3 no controle de potencia. Tem que ser antes da configuração, pois após ligar o periféricos, seus regs assumem valores padrões
    2304:	f043 7300 	orr.w	r3, r3, #33554432	; 0x2000000
    2308:	6013      	str	r3, [r2, #0]
	#if defined(arm7tdmi)
	U3_PINSEL = (U3_PINSEL & ~U3_PINMASK) | U3_PINS;			// Configura os pinos do uC para a função UART.
	#endif // arm7tdmi

	#if defined(cortexm3)
  	uart3_ConfigPort();
    230a:	4a1c      	ldr	r2, [pc, #112]	; (237c <uart3_Init+0x80>)
	U3_RTS_DIR |= U3_RTS; 				// Pino RTS como saída
	uart3_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U3IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
  	U3IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    230c:	4d1c      	ldr	r5, [pc, #112]	; (2380 <uart3_Init+0x84>)
	#if defined(arm7tdmi)
	U3_PINSEL = (U3_PINSEL & ~U3_PINMASK) | U3_PINS;			// Configura os pinos do uC para a função UART.
	#endif // arm7tdmi

	#if defined(cortexm3)
  	uart3_ConfigPort();
    230e:	6813      	ldr	r3, [r2, #0]
	U3_CTS_DIR &= ~U3_CTS; 				// Pino CTS como entrada
	U3_RTS_DIR |= U3_RTS; 				// Pino RTS como saída
	uart3_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U3IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    2310:	2600      	movs	r6, #0
	#if defined(arm7tdmi)
	U3_PINSEL = (U3_PINSEL & ~U3_PINMASK) | U3_PINS;			// Configura os pinos do uC para a função UART.
	#endif // arm7tdmi

	#if defined(cortexm3)
  	uart3_ConfigPort();
    2312:	f043 030a 	orr.w	r3, r3, #10
    2316:	6013      	str	r3, [r2, #0]
	U3_CTS_DIR &= ~U3_CTS; 				// Pino CTS como entrada
	U3_RTS_DIR |= U3_RTS; 				// Pino RTS como saída
	uart3_RTSon(); 						// Sinaliza que posso receber dados
	#endif

  	U3IER = 0;   	                      						// Desabilita todas as fonte de interrupções da uart
    2318:	6026      	str	r6, [r4, #0]
  	U3IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
    231a:	682b      	ldr	r3, [r5, #0]
  	U3FCR = (U3FCR_TX_FIFO_RESET | U3FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS
    231c:	2306      	movs	r3, #6
    231e:	602b      	str	r3, [r5, #0]

	uart3_SetBaudrate(baudrate);
    2320:	f7ff ff76 	bl	2210 <uart3_SetBaudrate>
  	
  	U3FCR = UART3_FIFOMODE;										// Configura o modo de trabalho da FIFO
    2324:	2701      	movs	r7, #1

	U3RBR;                                						// Limpa o registrador de recepçao de dados
    2326:	4b17      	ldr	r3, [pc, #92]	; (2384 <uart3_Init+0x88>)
  	U3IIR;                                						// Limpa os identificadores de pendencia interrupções da uart
  	U3FCR = (U3FCR_TX_FIFO_RESET | U3FCR_RX_FIFO_RESET);		// Limpa TX e RX FIFOS

	uart3_SetBaudrate(baudrate);
  	
  	U3FCR = UART3_FIFOMODE;										// Configura o modo de trabalho da FIFO
    2328:	602f      	str	r7, [r5, #0]

	U3RBR;                                						// Limpa o registrador de recepçao de dados
    232a:	681b      	ldr	r3, [r3, #0]
  	U3LSR;                                						// Limpa o registrador de estado de linha
    232c:	4b16      	ldr	r3, [pc, #88]	; (2388 <uart3_Init+0x8c>)
  	if (!irq_Install(VIC_UART3, uart3_ISR, UART3_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART3);
    232e:	2008      	movs	r0, #8
	uart3_SetBaudrate(baudrate);
  	
  	U3FCR = UART3_FIFOMODE;										// Configura o modo de trabalho da FIFO

	U3RBR;                                						// Limpa o registrador de recepçao de dados
  	U3LSR;                                						// Limpa o registrador de estado de linha
    2330:	681b      	ldr	r3, [r3, #0]
	U3FCR = U3FCR_RX_FIFO_RESET;								// Limpa a FIFO de recepção
    2332:	2302      	movs	r3, #2
    2334:	602b      	str	r3, [r5, #0]
  	U3FCR = U3FCR_TX_FIFO_RESET;          						// Limpa a FIFO de transmissão
    2336:	2304      	movs	r3, #4
    2338:	602b      	str	r3, [r5, #0]
  	if (!irq_Install(VIC_UART3, uart3_ISR, UART3_PRIO_LEVEL))
		return errIRQ_INSTALL;
	#endif

	#if defined (cortexm3)
	nvic_enableIRQ(VIC_UART3);
    233a:	f7ff fb5a 	bl	19f2 <nvic_enableIRQ>
	nvic_setPriority(VIC_UART3, UART3_PRIO_LEVEL);
    233e:	2103      	movs	r1, #3
    2340:	2008      	movs	r0, #8
    2342:	f7ff fb65 	bl	1a10 <nvic_setPriority>
	#if (USE_MALLOC == pdON)
	u3_data_rx = malloc(UART3_RX_BUFFER_SIZE*sizeof(u8));
	u3_data_tx = malloc(UART3_TX_BUFFER_SIZE*sizeof(u8));
	#endif

	buffer_Init(&u3_buf_rx, u3_data_rx, UART3_RX_BUFFER_SIZE);
    2346:	2296      	movs	r2, #150	; 0x96
    2348:	4910      	ldr	r1, [pc, #64]	; (238c <uart3_Init+0x90>)
    234a:	4811      	ldr	r0, [pc, #68]	; (2390 <uart3_Init+0x94>)
    234c:	f001 fdaa 	bl	3ea4 <buffer_Init>
	buffer_Init(&u3_buf_tx, u3_data_tx, UART3_TX_BUFFER_SIZE);
    2350:	2296      	movs	r2, #150	; 0x96
    2352:	4910      	ldr	r1, [pc, #64]	; (2394 <uart3_Init+0x98>)
    2354:	4810      	ldr	r0, [pc, #64]	; (2398 <uart3_Init+0x9c>)
    2356:	f001 fda5 	bl	3ea4 <buffer_Init>

	u3_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    235a:	4b10      	ldr	r3, [pc, #64]	; (239c <uart3_Init+0xa0>)
		
	U3IER |= U3IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
	U3IER &= ~U3IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão

	return pdPASS;
}
    235c:	4638      	mov	r0, r7
	#endif

	buffer_Init(&u3_buf_rx, u3_data_rx, UART3_RX_BUFFER_SIZE);
	buffer_Init(&u3_buf_tx, u3_data_tx, UART3_TX_BUFFER_SIZE);

	u3_overflow_rx = 0; 										// Limpa overflow do buffer de recepção
    235e:	801e      	strh	r6, [r3, #0]
	u3_tx_running = pdFALSE;
    2360:	4b0f      	ldr	r3, [pc, #60]	; (23a0 <uart3_Init+0xa4>)
    2362:	701e      	strb	r6, [r3, #0]
		
	U3IER |= U3IER_ERBFI;										// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    2364:	6823      	ldr	r3, [r4, #0]
    2366:	433b      	orrs	r3, r7
    2368:	6023      	str	r3, [r4, #0]
	U3IER &= ~U3IER_ETBEI;                						// Desabilita a interrupção de buffer vazio de transmissão
    236a:	6823      	ldr	r3, [r4, #0]
    236c:	f023 0302 	bic.w	r3, r3, #2
    2370:	6023      	str	r3, [r4, #0]

	return pdPASS;
}
    2372:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    2374:	400fc0c4 	.word	0x400fc0c4
    2378:	4009c004 	.word	0x4009c004
    237c:	4002c000 	.word	0x4002c000
    2380:	4009c008 	.word	0x4009c008
    2384:	4009c000 	.word	0x4009c000
    2388:	4009c014 	.word	0x4009c014
    238c:	100008ad 	.word	0x100008ad
    2390:	100009dc 	.word	0x100009dc
    2394:	10000943 	.word	0x10000943
    2398:	100008a0 	.word	0x100008a0
    239c:	100009da 	.word	0x100009da
    23a0:	100008ac 	.word	0x100008ac

Disassembly of section .text.uart3_GetChar:

000023a4 <uart3_GetChar>:
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Captura o próximo byte recebido na UART
// Parametros: 	Ponteiro para da variavel char para o retorno do byte recebido
// Retorna:		pdPASS indicando que existe caractere recebido ou o código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart3_GetChar(u8 *ch) {
    23a4:	b538      	push	{r3, r4, r5, lr}
    23a6:	4605      	mov	r5, r0
	int ret;

	if ( u3_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
    23a8:	480d      	ldr	r0, [pc, #52]	; (23e0 <uart3_GetChar+0x3c>)
    23aa:	8883      	ldrh	r3, [r0, #4]
    23ac:	b29b      	uxth	r3, r3
    23ae:	b18b      	cbz	r3, 23d4 <uart3_GetChar+0x30>
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro

	if ( u3_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
    23b0:	88c3      	ldrh	r3, [r0, #6]
    23b2:	b29b      	uxth	r3, r3
    23b4:	b18b      	cbz	r3, 23da <uart3_GetChar+0x36>
		U3IER &= ~U3IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    23b6:	4c0b      	ldr	r4, [pc, #44]	; (23e4 <uart3_GetChar+0x40>)
    23b8:	6823      	ldr	r3, [r4, #0]
    23ba:	f023 0301 	bic.w	r3, r3, #1
    23be:	6023      	str	r3, [r4, #0]
		nop();
    23c0:	bf00      	nop
		*ch = buffer_GetFromFront(&u3_buf_rx);				// Captura os dados do inicio do buffer
    23c2:	f001 fd75 	bl	3eb0 <buffer_GetFromFront>
    23c6:	7028      	strb	r0, [r5, #0]
		U3IER |= U3IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    23c8:	6823      	ldr	r3, [r4, #0]
		ret = pdPASS;
    23ca:	2001      	movs	r0, #1

	if ( u3_buf_rx.datalength ) {							// Checo de o buffer de recepção contêm dados recebidos pela UART
		U3IER &= ~U3IER_ERBFI;								// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		nop();
		*ch = buffer_GetFromFront(&u3_buf_rx);				// Captura os dados do inicio do buffer
		U3IER |= U3IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    23cc:	f043 0301 	orr.w	r3, r3, #1
    23d0:	6023      	str	r3, [r4, #0]
    23d2:	bd38      	pop	{r3, r4, r5, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart3_GetChar(u8 *ch) {
	int ret;

	if ( u3_buf_rx.size == 0 )								// Checa se o buffer de recepção ainda não foi criado
   		return errBUFFER_NO_EXIST;            				// Retorna indicando erro
    23d4:	f06f 000b 	mvn.w	r0, #11
    23d8:	bd38      	pop	{r3, r4, r5, pc}
		nop();
		*ch = buffer_GetFromFront(&u3_buf_rx);				// Captura os dados do inicio do buffer
		U3IER |= U3IER_ERBFI;								// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
		ret = pdPASS;
	} else
		ret = errBUFFER_EMPTY;
    23da:	f06f 000a 	mvn.w	r0, #10

	return ret;
}
    23de:	bd38      	pop	{r3, r4, r5, pc}
    23e0:	100009dc 	.word	0x100009dc
    23e4:	4009c004 	.word	0x4009c004

Disassembly of section .text.uart3_ClearBufferRx:

000023e8 <uart3_ClearBufferRx>:
// -----------------------------------------------------------------------------------------------------------------
// Descrição: 	Limpa o buffer e FIFO de recepção
// Parametros:	Nenhum
// Retorna:		Nada
// -----------------------------------------------------------------------------------------------------------------
void uart3_ClearBufferRx(void) {
    23e8:	b510      	push	{r4, lr}
	U3IER &= ~U3IER_ERBFI;				// Desabilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    23ea:	4c0a      	ldr	r4, [pc, #40]	; (2414 <uart3_ClearBufferRx+0x2c>)
    23ec:	6823      	ldr	r3, [r4, #0]
    23ee:	f023 0301 	bic.w	r3, r3, #1
    23f2:	6023      	str	r3, [r4, #0]
	nop();
    23f4:	bf00      	nop
	u3_overflow_rx = 0; 				// Limpa overflow do buffer de recepção
    23f6:	4b08      	ldr	r3, [pc, #32]	; (2418 <uart3_ClearBufferRx+0x30>)
    23f8:	2200      	movs	r2, #0
    23fa:	801a      	strh	r2, [r3, #0]
	U3FCR = U3FCR_RX_FIFO_RESET;		// Limpa RX FIFO
    23fc:	4b07      	ldr	r3, [pc, #28]	; (241c <uart3_ClearBufferRx+0x34>)
    23fe:	2202      	movs	r2, #2
    2400:	601a      	str	r2, [r3, #0]
	buffer_Clear(&u3_buf_rx);			// Limpa o buffer de recepção
    2402:	4807      	ldr	r0, [pc, #28]	; (2420 <uart3_ClearBufferRx+0x38>)
    2404:	f001 fd99 	bl	3f3a <buffer_Clear>
	U3IER |= U3IER_ERBFI;				// Habilita interrupção de dados prontos na recepção e CTI (SIMULADOR PROTEUS NÃO FUNCIONA CTI)
    2408:	6823      	ldr	r3, [r4, #0]
    240a:	f043 0301 	orr.w	r3, r3, #1
    240e:	6023      	str	r3, [r4, #0]
    2410:	bd10      	pop	{r4, pc}
    2412:	bf00      	nop
    2414:	4009c004 	.word	0x4009c004
    2418:	100009da 	.word	0x100009da
    241c:	4009c008 	.word	0x4009c008
    2420:	100009dc 	.word	0x100009dc

Disassembly of section .text.uart3_BufferQtdRx:

00002424 <uart3_BufferQtdRx>:
// Descrição: 	Retorna com a quantidade de bytes recebidos no buffer de recepção
// Parametros:	Nenhum
// Retorna:		Retorna com a quantidade de bytes recebidos no buffer de recepção
// -----------------------------------------------------------------------------------------------------------------
int uart3_BufferQtdRx(void) {
	return u3_buf_rx.datalength;
    2424:	4b01      	ldr	r3, [pc, #4]	; (242c <uart3_BufferQtdRx+0x8>)
    2426:	88d8      	ldrh	r0, [r3, #6]
}
    2428:	b280      	uxth	r0, r0
    242a:	4770      	bx	lr
    242c:	100009dc 	.word	0x100009dc

Disassembly of section .text.uart3_PutChar:

00002430 <uart3_PutChar>:
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart3_PutChar(n16 ch) {
	int sts;

	if ( u3_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    2430:	4b15      	ldr	r3, [pc, #84]	; (2488 <uart3_PutChar+0x58>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Coloca um caractere na fila de transmissão
// Parametros: 	Caractere a ser transmitindo
// Retorna:		Retorna pdPASS ou o código de erro
// -------------------------------------------------------------------------------------------------------------------
int uart3_PutChar(n16 ch) {
    2432:	b570      	push	{r4, r5, r6, lr}
	int sts;

	if ( u3_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
    2434:	889b      	ldrh	r3, [r3, #4]
    2436:	b29b      	uxth	r3, r3
    2438:	b303      	cbz	r3, 247c <uart3_PutChar+0x4c>
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U3IER &= ~U3IER_ETBEI;                 								// Desativa a interrupção de transmissão
    243a:	4c14      	ldr	r4, [pc, #80]	; (248c <uart3_PutChar+0x5c>)
		nop();
		sts = buffer_AddToEnd(&u3_buf_tx, ch);
    243c:	b2c5      	uxtb	r5, r0
	// É obrigatório incluirmos o char no buffer, mesmo que vamos retirá-lo logo em seguida caso u3_tx_running for FALSE
	//	Se não for dessa forma o e usar U3THR = ch haverá erro de sincronismo entre os dados chegas e dados enviados.
	// Isto porque o manipulador de interrupção (uart3_ISR) pode atender a mais de uma interrupção simulataneas

	do {
		U3IER &= ~U3IER_ETBEI;                 								// Desativa a interrupção de transmissão
    243e:	6823      	ldr	r3, [r4, #0]
    2440:	4e12      	ldr	r6, [pc, #72]	; (248c <uart3_PutChar+0x5c>)
    2442:	f023 0302 	bic.w	r3, r3, #2
    2446:	6023      	str	r3, [r4, #0]
		nop();
    2448:	bf00      	nop
		sts = buffer_AddToEnd(&u3_buf_tx, ch);
    244a:	480f      	ldr	r0, [pc, #60]	; (2488 <uart3_PutChar+0x58>)
    244c:	4629      	mov	r1, r5
    244e:	f001 fd51 	bl	3ef4 <buffer_AddToEnd>
		U3IER |= U3IER_ETBEI;                  								// Habilita a interrupção de transmissão
    2452:	6823      	ldr	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    2454:	300a      	adds	r0, #10

	do {
		U3IER &= ~U3IER_ETBEI;                 								// Desativa a interrupção de transmissão
		nop();
		sts = buffer_AddToEnd(&u3_buf_tx, ch);
		U3IER |= U3IER_ETBEI;                  								// Habilita a interrupção de transmissão
    2456:	f043 0302 	orr.w	r3, r3, #2
    245a:	6023      	str	r3, [r4, #0]

		CRITICAL_WAIT;														// Caso exista algum OS, pode trocar de contexto
	} while (sts == errBUFFER_FULL);
    245c:	d0ef      	beq.n	243e <uart3_PutChar+0xe>

	if (!u3_tx_running) {													// Checa se existe dado sendo transmitido
    245e:	4c0c      	ldr	r4, [pc, #48]	; (2490 <uart3_PutChar+0x60>)
    2460:	7823      	ldrb	r3, [r4, #0]
    2462:	b973      	cbnz	r3, 2482 <uart3_PutChar+0x52>
  		U3THR = buffer_GetFromFront(&u3_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
    2464:	4808      	ldr	r0, [pc, #32]	; (2488 <uart3_PutChar+0x58>)
    2466:	f001 fd23 	bl	3eb0 <buffer_GetFromFront>
    246a:	4b0a      	ldr	r3, [pc, #40]	; (2494 <uart3_PutChar+0x64>)
    246c:	6018      	str	r0, [r3, #0]
  		u3_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
    246e:	2001      	movs	r0, #1
    2470:	7020      	strb	r0, [r4, #0]
  		U3IER |= U3IER_ETBEI;                  								// Habilita a interrupção de transmissão
    2472:	6833      	ldr	r3, [r6, #0]
    2474:	f043 0302 	orr.w	r3, r3, #2
    2478:	6033      	str	r3, [r6, #0]
    247a:	bd70      	pop	{r4, r5, r6, pc}
// -------------------------------------------------------------------------------------------------------------------
int uart3_PutChar(n16 ch) {
	int sts;

	if ( u3_buf_tx.size == 0 )												// Checa se o buffer de transmissão ainda não foi criado
   		return errBUFFER_NO_EXIST;                          				// Retorna indicando erro
    247c:	f06f 000b 	mvn.w	r0, #11
    2480:	bd70      	pop	{r4, r5, r6, pc}
  		U3THR = buffer_GetFromFront(&u3_buf_tx);							// Atribui o dado do buffer ao registrador de transmissão
  		u3_tx_running = pdTRUE;												// Sinaliza que existe dado sendo trasnmitido
  		U3IER |= U3IER_ETBEI;                  								// Habilita a interrupção de transmissão
   	}

  	return pdPASS;
    2482:	2001      	movs	r0, #1
}
    2484:	bd70      	pop	{r4, r5, r6, pc}
    2486:	bf00      	nop
    2488:	100008a0 	.word	0x100008a0
    248c:	4009c004 	.word	0x4009c004
    2490:	100008ac 	.word	0x100008ac
    2494:	4009c000 	.word	0x4009c000

Disassembly of section .text.uart3_SpaceTx:

00002498 <uart3_SpaceTx>:
// Retorna:		O tamanho em bytes do espaço disponivel para transmissão
// -------------------------------------------------------------------------------------------------------------------
u16 uart3_SpaceTx(void) {
	u16 qtd;
	
	U3IER &= ~U3IER_ETBEI;                 								// Desativa a interrupção de transmissão
    2498:	4b07      	ldr	r3, [pc, #28]	; (24b8 <uart3_SpaceTx+0x20>)
    249a:	681a      	ldr	r2, [r3, #0]
    249c:	f022 0202 	bic.w	r2, r2, #2
    24a0:	601a      	str	r2, [r3, #0]
	nop();
    24a2:	bf00      	nop
	qtd = (u16)(u3_buf_tx.size - u3_buf_tx.datalength);					// Retorna com o espaço disponivel
    24a4:	4905      	ldr	r1, [pc, #20]	; (24bc <uart3_SpaceTx+0x24>)
    24a6:	888a      	ldrh	r2, [r1, #4]
    24a8:	88c8      	ldrh	r0, [r1, #6]
	U3IER |= U3IER_ETBEI;                  								// Habilita a interrupção de transmissão
    24aa:	6819      	ldr	r1, [r3, #0]
	return qtd;
    24ac:	1a10      	subs	r0, r2, r0
	u16 qtd;
	
	U3IER &= ~U3IER_ETBEI;                 								// Desativa a interrupção de transmissão
	nop();
	qtd = (u16)(u3_buf_tx.size - u3_buf_tx.datalength);					// Retorna com o espaço disponivel
	U3IER |= U3IER_ETBEI;                  								// Habilita a interrupção de transmissão
    24ae:	f041 0102 	orr.w	r1, r1, #2
    24b2:	6019      	str	r1, [r3, #0]
	return qtd;
}
    24b4:	b280      	uxth	r0, r0
    24b6:	4770      	bx	lr
    24b8:	4009c004 	.word	0x4009c004
    24bc:	100008a0 	.word	0x100008a0

Disassembly of section .text.uart3_EmptyTx:

000024c0 <uart3_EmptyTx>:
// Parametros: 	Nenhum
// Retorna:		pdFALSE = Se o registradores U0THR ou U0TSR não estão vazios
//				pdTRUE = Se o registradores U0THR ou U0TSR estão vazios
// -------------------------------------------------------------------------------------------------------------------
int uart3_EmptyTx(void) {
  	if ((U3LSR & (U3LSR_THRE | U3LSR_TEMT)) == (U3LSR_THRE | U3LSR_TEMT))
    24c0:	4b04      	ldr	r3, [pc, #16]	; (24d4 <uart3_EmptyTx+0x14>)
    24c2:	6818      	ldr	r0, [r3, #0]
    24c4:	f000 0060 	and.w	r0, r0, #96	; 0x60
  			return pdTRUE;
  	else	return pdFALSE;
}
    24c8:	f1a0 0360 	sub.w	r3, r0, #96	; 0x60
    24cc:	4258      	negs	r0, r3
    24ce:	4158      	adcs	r0, r3
    24d0:	4770      	bx	lr
    24d2:	bf00      	nop
    24d4:	4009c014 	.word	0x4009c014

Disassembly of section .text.uart3_WriteTx:

000024d8 <uart3_WriteTx>:
// Descrição:	Adiociona N caracteres no buffer de transmissão
// Parametros: 	Ponteiro do buffer 
//				Quantidade de caracteres as serem transmitidos
// Retorna:		pdPASS = Transmitido com sucesso ou o código do erro
// -------------------------------------------------------------------------------------------------------------------
int uart3_WriteTx(u8 *buffer, u16 count) {
    24d8:	b538      	push	{r3, r4, r5, lr}
    24da:	460c      	mov	r4, r1
    24dc:	4605      	mov	r5, r0
	if (count > uart3_SpaceTx())									// Checa se exste espaço suficiente no buffer de TX de espaço insuficiente
    24de:	f7ff ffdb 	bl	2498 <uart3_SpaceTx>
    24e2:	42a0      	cmp	r0, r4
    24e4:	d20a      	bcs.n	24fc <uart3_WriteTx+0x24>
   		return errBUFFER_FULL;										// Retorna cheio
    24e6:	f06f 0009 	mvn.w	r0, #9
    24ea:	bd38      	pop	{r3, r4, r5, pc}
  	
  	while (count && (uart3_PutChar(*buffer++) >= 0))				// Faça enquanto tem dados a serem transmitidos
    24ec:	f815 0b01 	ldrb.w	r0, [r5], #1
    24f0:	f7ff ff9e 	bl	2430 <uart3_PutChar>
    24f4:	2800      	cmp	r0, #0
    24f6:	dbf6      	blt.n	24e6 <uart3_WriteTx+0xe>
    	count--;
    24f8:	3c01      	subs	r4, #1
    24fa:	b2a4      	uxth	r4, r4
// -------------------------------------------------------------------------------------------------------------------
int uart3_WriteTx(u8 *buffer, u16 count) {
	if (count > uart3_SpaceTx())									// Checa se exste espaço suficiente no buffer de TX de espaço insuficiente
   		return errBUFFER_FULL;										// Retorna cheio
  	
  	while (count && (uart3_PutChar(*buffer++) >= 0))				// Faça enquanto tem dados a serem transmitidos
    24fc:	2c00      	cmp	r4, #0
    24fe:	d1f5      	bne.n	24ec <uart3_WriteTx+0x14>
    	count--;

  	return (count ? errBUFFER_FULL : pdPASS);						// Se count = 0 retorna 0 (Sucesso) senão retorna -2 (erro)
    2500:	2001      	movs	r0, #1
}
    2502:	bd38      	pop	{r3, r4, r5, pc}

Disassembly of section .text.uart3_ISR:

00002504 <uart3_ISR>:
//###################################################################################################################
// UART SERVIÇO DE INTERRUPÇÕES
// 		Descrição: 	Esta função implementa o ISR da UART3
//###################################################################################################################
//###################################################################################################################
void uart3_ISR (void) {
    2504:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;

  	while ( !((int_flags = U3IIR) & U3IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART
    2508:	4e23      	ldr	r6, [pc, #140]	; (2598 <uart3_ISR+0x94>)
    250a:	4c24      	ldr	r4, [pc, #144]	; (259c <uart3_ISR+0x98>)
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
	  	case U3IIR_THRE_INT:              									// Interrupção da FIFO de 16 bytes quando está vazia
	  		while (U3LSR & U3LSR_THRE) {									// Faça enquanto há espaço na FIFO
	  			if (buffer_IsEmpty(&u3_buf_tx) ) {						 	// Checa se o buffer de transmissão já está vazio
	    			u3_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
	    			U3IER &= ~U3IER_ETBEI;                					// Desativa a interrupção de transmissão
    250c:	4d24      	ldr	r5, [pc, #144]	; (25a0 <uart3_ISR+0x9c>)
void uart3_ISR (void) {
	ISR_ENTRY;																// Procedimento para entrada da interrupção

  	u8 int_flags;

  	while ( !((int_flags = U3IIR) & U3IIR_NO_INT) ) {							// Faça para todos os pedidos de interrupção pendentes emitidos pela UART
    250e:	6833      	ldr	r3, [r6, #0]
    2510:	b2db      	uxtb	r3, r3
    2512:	07da      	lsls	r2, r3, #31
    2514:	d43a      	bmi.n	258c <uart3_ISR+0x88>
  		switch (int_flags & U3IIR_ID_MASK) {									// Identifica a fonte de interrupção
    2516:	f003 030e 	and.w	r3, r3, #14
    251a:	3b02      	subs	r3, #2
    251c:	2b0a      	cmp	r3, #10
    251e:	d831      	bhi.n	2584 <uart3_ISR+0x80>
    2520:	e8df f003 	tbb	[pc, r3]
    2524:	3008301b 	.word	0x3008301b
    2528:	30303006 	.word	0x30303006
    252c:	3030      	.short	0x3030
    252e:	08          	.byte	0x08
    252f:	00          	.byte	0x00
  		case U3IIR_RLS_INT:                									// Caso recebeu uma INT de erro na linha de recepção (receive line status)
  			U3LSR;                         									// Limpa registrador de status de linha
    2530:	6823      	ldr	r3, [r4, #0]
        	break;
    2532:	e7ec      	b.n	250e <uart3_ISR+0xa>
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U3IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U3IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
     		do {
    			if (buffer_AddToEnd(&u3_buf_rx, U3RBR) == errBUFFER_FULL)
    2534:	f8df 8074 	ldr.w	r8, [pc, #116]	; 25ac <uart3_ISR+0xa8>
					u3_overflow_rx++;
    2538:	4f1a      	ldr	r7, [pc, #104]	; (25a4 <uart3_ISR+0xa0>)
        	// não alcançar o nível do trigger os dados da FIFO serão adicionados
        	// ao buffer de recepção pela interrupção de timerout da UART (U3IIR_CTI_INT)
      	case U3IIR_CTI_INT:                									// Character Timeout Indicator. Dados na FIFO RX que não foram lidos e está abaixo do nível de gatilho de int
      	case U3IIR_RDA_INT:                									// Caso que exista bytes disponivel recepção
     		do {
    			if (buffer_AddToEnd(&u3_buf_rx, U3RBR) == errBUFFER_FULL)
    253a:	f8d8 1000 	ldr.w	r1, [r8]
    253e:	481a      	ldr	r0, [pc, #104]	; (25a8 <uart3_ISR+0xa4>)
    2540:	b2c9      	uxtb	r1, r1
    2542:	f001 fcd7 	bl	3ef4 <buffer_AddToEnd>
    2546:	300a      	adds	r0, #10
					u3_overflow_rx++;
    2548:	bf01      	itttt	eq
    254a:	883b      	ldrheq	r3, [r7, #0]
    254c:	3301      	addeq	r3, #1
    254e:	b29b      	uxtheq	r3, r3
    2550:	803b      	strheq	r3, [r7, #0]
      		} while(U3LSR & U3LSR_RDR);										// Faça enquanto existe dados validos na FIFO de recepção
    2552:	6823      	ldr	r3, [r4, #0]
    2554:	07d8      	lsls	r0, r3, #31
    2556:	d4f0      	bmi.n	253a <uart3_ISR+0x36>
    2558:	e7d9      	b.n	250e <uart3_ISR+0xa>
	      			break;
	    		} else {
					#if (UART3_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart3_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	    				U3THR = buffer_GetFromFront(&u3_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    255a:	4f14      	ldr	r7, [pc, #80]	; (25ac <uart3_ISR+0xa8>)

     	// RETIRA OS DADOS DO BUFFER TX PARA A FIFO DE TRANSMISSÃO
     		// Essa interrupção é gerada quando a FIFO de transmissão de 16 bytes está vazia
			// O registrador UxTHR é o topo da FIFO de 16 bytes, ou seja, é o endereço da última posição a ser inserida da FIFO
	  	case U3IIR_THRE_INT:              									// Interrupção da FIFO de 16 bytes quando está vazia
	  		while (U3LSR & U3LSR_THRE) {									// Faça enquanto há espaço na FIFO
    255c:	6823      	ldr	r3, [r4, #0]
    255e:	0699      	lsls	r1, r3, #26
    2560:	d5d5      	bpl.n	250e <uart3_ISR+0xa>
	  			if (buffer_IsEmpty(&u3_buf_tx) ) {						 	// Checa se o buffer de transmissão já está vazio
    2562:	4813      	ldr	r0, [pc, #76]	; (25b0 <uart3_ISR+0xac>)
    2564:	f001 fce3 	bl	3f2e <buffer_IsEmpty>
    2568:	b138      	cbz	r0, 257a <uart3_ISR+0x76>
	    			u3_tx_running = pdFALSE;     							// Sinaliza que não existe dados para trasnmissao
    256a:	4b12      	ldr	r3, [pc, #72]	; (25b4 <uart3_ISR+0xb0>)
    256c:	2200      	movs	r2, #0
    256e:	701a      	strb	r2, [r3, #0]
	    			U3IER &= ~U3IER_ETBEI;                					// Desativa a interrupção de transmissão
    2570:	682b      	ldr	r3, [r5, #0]
    2572:	f023 0302 	bic.w	r3, r3, #2
    2576:	602b      	str	r3, [r5, #0]
	      			break;
    2578:	e7c9      	b.n	250e <uart3_ISR+0xa>
	    		} else {
					#if (UART3_USE_HANDSHAKING == pdON) // AINDA NÃO TESTADO
	    			if (uart3_CTS()) // Checa se o receptor esteja pronto para eviar dados
					#endif
	    				U3THR = buffer_GetFromFront(&u3_buf_tx);			// Atribui o dado do buffer ao registrador de transmissão
    257a:	480d      	ldr	r0, [pc, #52]	; (25b0 <uart3_ISR+0xac>)
    257c:	f001 fc98 	bl	3eb0 <buffer_GetFromFront>
    2580:	6038      	str	r0, [r7, #0]
    2582:	e7eb      	b.n	255c <uart3_ISR+0x58>
	    	}

	    	break;

      	default:															// Interrupção desconhecida
      		U3LSR;															// Limpa registrador de status de linha
    2584:	6823      	ldr	r3, [r4, #0]
        	U3RBR;															// Limpa o registrador de recepçao de dados
    2586:	4b09      	ldr	r3, [pc, #36]	; (25ac <uart3_ISR+0xa8>)
    2588:	681b      	ldr	r3, [r3, #0]
        	break;
    258a:	e7c0      	b.n	250e <uart3_ISR+0xa>
  	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART3);
	#endif
	#if defined (cortexm3)
  	nvic_clearPendingIRQ(VIC_UART3);
    258c:	2008      	movs	r0, #8
	#endif

    ISR_EXIT;																// Procedimento para saida da interrupção
}
    258e:	e8bd 41f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, lr}
  	// Limpa interrupção
  	#if defined(arm7tdmi)
  	VICSoftIntClr = (1<<VIC_UART3);
	#endif
	#if defined (cortexm3)
  	nvic_clearPendingIRQ(VIC_UART3);
    2592:	f7ff ba31 	b.w	19f8 <nvic_clearPendingIRQ>
    2596:	bf00      	nop
    2598:	4009c008 	.word	0x4009c008
    259c:	4009c014 	.word	0x4009c014
    25a0:	4009c004 	.word	0x4009c004
    25a4:	100009da 	.word	0x100009da
    25a8:	100009dc 	.word	0x100009dc
    25ac:	4009c000 	.word	0x4009c000
    25b0:	100008a0 	.word	0x100008a0
    25b4:	100008ac 	.word	0x100008ac

Disassembly of section .text.showVicError:

000025b8 <showVicError>:
#include "vic.h"
#include "app.h"
#include "uart0_irq.h"

static void showVicError(int n) {
    25b8:	e92d 4888 	stmdb	sp!, {r3, r7, fp, lr}
	irq_Disable();
    25bc:	b672      	cpsid	i
    25be:	280a      	cmp	r0, #10
    25c0:	bfa8      	it	ge
    25c2:	200a      	movge	r0, #10
    25c4:	4604      	mov	r4, r0

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    25c6:	4d14      	ldr	r5, [pc, #80]	; (2618 <showVicError+0x60>)
			ledERROR_On();	buzzer_On();	delay_ms(250);
    25c8:	f8df 905c 	ldr.w	r9, [pc, #92]	; 2628 <showVicError+0x70>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    25cc:	f04f 0800 	mov.w	r8, #0
    25d0:	f8df a044 	ldr.w	sl, [pc, #68]	; 2618 <showVicError+0x60>
			ledERROR_On();	buzzer_On();	delay_ms(250);
    25d4:	f8df b054 	ldr.w	fp, [pc, #84]	; 262c <showVicError+0x74>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    25d8:	f8c5 8000 	str.w	r8, [r5]
    25dc:	f8da 3000 	ldr.w	r3, [sl]
    25e0:	429c      	cmp	r4, r3
    25e2:	dd15      	ble.n	2610 <showVicError+0x58>
			ledERROR_On();	buzzer_On();	delay_ms(250);
    25e4:	f04f 5700 	mov.w	r7, #536870912	; 0x20000000
    25e8:	f44f 0680 	mov.w	r6, #4194304	; 0x400000
    25ec:	f8c9 7000 	str.w	r7, [r9]
    25f0:	480a      	ldr	r0, [pc, #40]	; (261c <showVicError+0x64>)
    25f2:	f8cb 6000 	str.w	r6, [fp]
    25f6:	f7ff fa9d 	bl	1b34 <delay>
			ledERROR_Off();	buzzer_Off();	delay_ms(250);
    25fa:	4b09      	ldr	r3, [pc, #36]	; (2620 <showVicError+0x68>)
    25fc:	4807      	ldr	r0, [pc, #28]	; (261c <showVicError+0x64>)
    25fe:	601f      	str	r7, [r3, #0]
    2600:	f843 6c80 	str.w	r6, [r3, #-128]
    2604:	f7ff fa96 	bl	1b34 <delay>
	irq_Disable();

	static int x;
	if (n>10) n=10;
	while(1) {
		for (x=0;x<n;x++) {
    2608:	682b      	ldr	r3, [r5, #0]
    260a:	3301      	adds	r3, #1
    260c:	602b      	str	r3, [r5, #0]
    260e:	e7e5      	b.n	25dc <showVicError+0x24>
			ledERROR_On();	buzzer_On();	delay_ms(250);
			ledERROR_Off();	buzzer_Off();	delay_ms(250);
		}
		delay_ms(1000);
    2610:	4804      	ldr	r0, [pc, #16]	; (2624 <showVicError+0x6c>)
    2612:	f7ff fa8f 	bl	1b34 <delay>
	}
    2616:	e7db      	b.n	25d0 <showVicError+0x18>
    2618:	100009e8 	.word	0x100009e8
    261c:	007f26c8 	.word	0x007f26c8
    2620:	2009c09c 	.word	0x2009c09c
    2624:	01fc9f08 	.word	0x01fc9f08
    2628:	2009c098 	.word	0x2009c098
    262c:	2009c018 	.word	0x2009c018

Disassembly of section .text.startup.main:

00002630 <main>:
}

int main(void) {
    2630:	b508      	push	{r3, lr}
	nvic_SetIntHandler(showVicError);
    2632:	4821      	ldr	r0, [pc, #132]	; (26b8 <main+0x88>)
    2634:	f7ff fa0e 	bl	1a54 <nvic_SetIntHandler>
	// NÃO USAR UART COM INTERRUPÇÃO PARA O LOG, POIS CONSTANTEMENTE A
  	// POSIÇÃO DOS VETORES DE INTERRUPÇÕES COM O USO DO BOOTLOADER

  	// REGISTRANDO AS ENTRADAS E SAÍDAS PADRÃO AOS SEUS RESPECTIVOS DISPOSTIVOS
	// PORTA PARA CLI DEVE SER COM INTERRUPÇÃO
  	lgetchar_RegisterDev(uart0_GetChar);
    2638:	4820      	ldr	r0, [pc, #128]	; (26bc <main+0x8c>)
    263a:	f001 fa41 	bl	3ac0 <lgetchar_RegisterDev>
	lputchar_RegisterDev(uart0_PutChar);
    263e:	4820      	ldr	r0, [pc, #128]	; (26c0 <main+0x90>)
    2640:	f001 fa32 	bl	3aa8 <lputchar_RegisterDev>
	ldebug_RegisterDev(uart0_BasicPutChar);
    2644:	481f      	ldr	r0, [pc, #124]	; (26c4 <main+0x94>)
    2646:	f001 fa35 	bl	3ab4 <ldebug_RegisterDev>
	uart0_Init(115200);
    264a:	f44f 30e1 	mov.w	r0, #115200	; 0x1c200
    264e:	f7ff faed 	bl	1c2c <uart0_Init>

	systime_Init();
    2652:	f7ff fa05 	bl	1a60 <systime_Init>
	systime_SetIntHandler(app_Tick, 1); // Chamar o a função callsystem a cada 1ms OBS: Levando em consideração o SYSTIME_IRQ_TICK_DIV
    2656:	2101      	movs	r1, #1
    2658:	481b      	ldr	r0, [pc, #108]	; (26c8 <main+0x98>)
    265a:	f7ff fa2f 	bl	1abc <systime_SetIntHandler>
	ledError_Init();
    265e:	f001 fd0d 	bl	407c <ledError_Init>
	beep_Init();
    2662:	f001 fe13 	bl	428c <beep_Init>
	gKey_Init(onKeyDown, &onKeyPress, &onKeyUp);	// Anexar os eventos do teclado
    2666:	4a19      	ldr	r2, [pc, #100]	; (26cc <main+0x9c>)
    2668:	4919      	ldr	r1, [pc, #100]	; (26d0 <main+0xa0>)
    266a:	481a      	ldr	r0, [pc, #104]	; (26d4 <main+0xa4>)
    266c:	f001 fd5a 	bl	4124 <gKey_Init>

	lcd_Init(16, 2, LCD_5x8DOTS);
    2670:	2200      	movs	r2, #0
    2672:	2102      	movs	r1, #2
    2674:	2010      	movs	r0, #16
    2676:	f002 f84d 	bl	4714 <lcd_Init>
	lcd_printfInit(16, STDIO_DEV1);
    267a:	2104      	movs	r1, #4
    267c:	2010      	movs	r0, #16
    267e:	f002 f8a1 	bl	47c4 <lcd_printfInit>

	irq_Enable(); 	// Habilitar interrupções
    2682:	b662      	cpsie	i
	app_Init();
    2684:	f000 f900 	bl	2888 <app_Init>

	lprintf(CMD_TERMINATOR);
    2688:	4913      	ldr	r1, [pc, #76]	; (26d8 <main+0xa8>)
    268a:	2001      	movs	r0, #1
    268c:	f001 fbe0 	bl	3e50 <rprintf>
	lprintf(PROGAM_NAME);
    2690:	4912      	ldr	r1, [pc, #72]	; (26dc <main+0xac>)
    2692:	2001      	movs	r0, #1
    2694:	f001 fbdc 	bl	3e50 <rprintf>
	lprintf("ucLibc version "__VERSION CMD_TERMINATOR);
    2698:	4911      	ldr	r1, [pc, #68]	; (26e0 <main+0xb0>)
    269a:	2001      	movs	r0, #1
    269c:	f001 fbd8 	bl	3e50 <rprintf>

	while (1) {
		prompt_Process();
		app_Process();
		gKey_Process(control.key); // se há tecla pressiona o processo vai chamar os onKeyXXXX
    26a0:	4c10      	ldr	r4, [pc, #64]	; (26e4 <main+0xb4>)
	lprintf(CMD_TERMINATOR);
	lprintf(PROGAM_NAME);
	lprintf("ucLibc version "__VERSION CMD_TERMINATOR);

	while (1) {
		prompt_Process();
    26a2:	f000 fbb3 	bl	2e0c <prompt_Process>
		app_Process();
    26a6:	f000 f97b 	bl	29a0 <app_Process>
		gKey_Process(control.key); // se há tecla pressiona o processo vai chamar os onKeyXXXX
    26aa:	7b20      	ldrb	r0, [r4, #12]
    26ac:	f001 fd56 	bl	415c <gKey_Process>
		modbus_Process();
    26b0:	f000 fd5e 	bl	3170 <modbus_Process>
    26b4:	e7f5      	b.n	26a2 <main+0x72>
    26b6:	bf00      	nop
    26b8:	000025b9 	.word	0x000025b9
    26bc:	00001cdd 	.word	0x00001cdd
    26c0:	00001d21 	.word	0x00001d21
    26c4:	00001d89 	.word	0x00001d89
    26c8:	000028f9 	.word	0x000028f9
    26cc:	000027b1 	.word	0x000027b1
    26d0:	00002799 	.word	0x00002799
    26d4:	00002765 	.word	0x00002765
    26d8:	00004f35 	.word	0x00004f35
    26dc:	00004e90 	.word	0x00004e90
    26e0:	00005058 	.word	0x00005058
    26e4:	100005ac 	.word	0x100005ac

Disassembly of section .text.breakFloat:

000026e8 <breakFloat>:

// #######################################################################################################
// MISC
// #######################################################################################################
// retorna com a parte inteira e fracionaira de uma var que tem seu valor mul por 10 para deslocar a parte fracionaria
void breakFloat(s32 value, int* integer, int* digit) {
    26e8:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
    26ec:	4604      	mov	r4, r0
	int d = *digit;

	d =  value-((value/10)*10);
    26ee:	200a      	movs	r0, #10
    26f0:	fb94 f3f0 	sdiv	r3, r4, r0
	if (value >= 0)	d = fabs((double)d);
    26f4:	2c00      	cmp	r4, #0

// #######################################################################################################
// MISC
// #######################################################################################################
// retorna com a parte inteira e fracionaira de uma var que tem seu valor mul por 10 para deslocar a parte fracionaria
void breakFloat(s32 value, int* integer, int* digit) {
    26f6:	460d      	mov	r5, r1
    26f8:	4690      	mov	r8, r2
	int d = *digit;

	d =  value-((value/10)*10);
    26fa:	fb00 4013 	mls	r0, r0, r3, r4
	if (value >= 0)	d = fabs((double)d);
    26fe:	db06      	blt.n	270e <breakFloat+0x26>
    2700:	f7fd ff4e 	bl	5a0 <__aeabi_i2d>
    2704:	f021 4700 	bic.w	r7, r1, #2147483648	; 0x80000000
    2708:	4639      	mov	r1, r7
    270a:	f7fe fa49 	bl	ba0 <__aeabi_d2iz>
	*digit = d;
	*integer = value/10;
    270e:	230a      	movs	r3, #10
    2710:	fb94 f4f3 	sdiv	r4, r4, r3
void breakFloat(s32 value, int* integer, int* digit) {
	int d = *digit;

	d =  value-((value/10)*10);
	if (value >= 0)	d = fabs((double)d);
	*digit = d;
    2714:	f8c8 0000 	str.w	r0, [r8]
	*integer = value/10;
    2718:	602c      	str	r4, [r5, #0]
    271a:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}

Disassembly of section .text.stringFloat:

00002720 <stringFloat>:
}

void stringFloat(pchar s, int integer, int digit) {
	if ( digit < 0) {
    2720:	1e13      	subs	r3, r2, #0
    2722:	da05      	bge.n	2730 <stringFloat+0x10>
    2724:	425b      	negs	r3, r3
		if ( integer == 0 )	sformat(s, "-0.%d", ~digit+1);
    2726:	b919      	cbnz	r1, 2730 <stringFloat+0x10>
    2728:	461a      	mov	r2, r3
    272a:	4903      	ldr	r1, [pc, #12]	; (2738 <stringFloat+0x18>)
    272c:	f001 bba5 	b.w	3e7a <sformat>
		else sformat(s, "%d.%d", integer, ~digit+1);
	} else	sformat(s, "%d.%d", integer, digit);
    2730:	460a      	mov	r2, r1
    2732:	4902      	ldr	r1, [pc, #8]	; (273c <stringFloat+0x1c>)
    2734:	f001 bba1 	b.w	3e7a <sformat>
    2738:	00004ed0 	.word	0x00004ed0
    273c:	00004ed6 	.word	0x00004ed6

Disassembly of section .text.temp_InitStatistic:

00002740 <temp_InitStatistic>:
// #######################################################################################################
// TEMPEARTURA
// #######################################################################################################

void temp_InitStatistic(void) {
	control.action = pdTRUE;
    2740:	4a02      	ldr	r2, [pc, #8]	; (274c <temp_InitStatistic+0xc>)
    2742:	7813      	ldrb	r3, [r2, #0]
	control.setTempStatics = pdTRUE;
    2744:	f043 0303 	orr.w	r3, r3, #3
    2748:	7013      	strb	r3, [r2, #0]
    274a:	4770      	bx	lr
    274c:	100005ac 	.word	0x100005ac

Disassembly of section .text.temp_SetType:

00002750 <temp_SetType>:
// Especifica em que grandeza de temperatura os termômetros devem ser configurado
//		0 = Tratamento da temperatura determinada pelo jumper do termômetro
// 		1 = Configurar todos os termômetros a trabalhar com graus Celcius(0)
//		2 = Configurar todos os termômetros a trabalhar com graus Fahrenheit(1)
void temp_SetType(uint type) {
	control.action = pdTRUE;
    2750:	4b03      	ldr	r3, [pc, #12]	; (2760 <temp_SetType+0x10>)
    2752:	781a      	ldrb	r2, [r3, #0]
	control.setTempType = pdTRUE;
	control.tempType = type;
    2754:	6058      	str	r0, [r3, #4]
//		0 = Tratamento da temperatura determinada pelo jumper do termômetro
// 		1 = Configurar todos os termômetros a trabalhar com graus Celcius(0)
//		2 = Configurar todos os termômetros a trabalhar com graus Fahrenheit(1)
void temp_SetType(uint type) {
	control.action = pdTRUE;
	control.setTempType = pdTRUE;
    2756:	f042 0205 	orr.w	r2, r2, #5
    275a:	701a      	strb	r2, [r3, #0]
	control.tempType = type;
    275c:	4770      	bx	lr
    275e:	bf00      	nop
    2760:	100005ac 	.word	0x100005ac

Disassembly of section .text.onKeyDown:

00002764 <onKeyDown>:
}

// #######################################################################################################
// KEYBOARD
// #######################################################################################################
void onKeyDown(char key) {
    2764:	b510      	push	{r4, lr}
    2766:	4604      	mov	r4, r0
	lprintf("onKeyDown key [0x%x]"CMD_TERMINATOR, key);
    2768:	4602      	mov	r2, r0
    276a:	490a      	ldr	r1, [pc, #40]	; (2794 <onKeyDown+0x30>)
    276c:	2001      	movs	r0, #1
    276e:	f001 fb6f 	bl	3e50 <rprintf>
	if (key == SW0) beep_Play(4);
    2772:	2c01      	cmp	r4, #1
    2774:	d101      	bne.n	277a <onKeyDown+0x16>
    2776:	2004      	movs	r0, #4
    2778:	e006      	b.n	2788 <onKeyDown+0x24>
	else if (key == SW1) beep_Play(5);
    277a:	2c02      	cmp	r4, #2
    277c:	d101      	bne.n	2782 <onKeyDown+0x1e>
    277e:	2005      	movs	r0, #5
    2780:	e002      	b.n	2788 <onKeyDown+0x24>
	else if (key == SW2) beep_Play(6);
    2782:	2c04      	cmp	r4, #4
    2784:	d104      	bne.n	2790 <onKeyDown+0x2c>
    2786:	2006      	movs	r0, #6
}
    2788:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
// #######################################################################################################
void onKeyDown(char key) {
	lprintf("onKeyDown key [0x%x]"CMD_TERMINATOR, key);
	if (key == SW0) beep_Play(4);
	else if (key == SW1) beep_Play(5);
	else if (key == SW2) beep_Play(6);
    278c:	f001 bd94 	b.w	42b8 <beep_Play>
    2790:	bd10      	pop	{r4, pc}
    2792:	bf00      	nop
    2794:	00004edc 	.word	0x00004edc

Disassembly of section .text.onKeyPress:

00002798 <onKeyPress>:
}

void onKeyPress(char key __attribute__ ((unused)) ) {
	lprintf("onKeyPress key [0x%x] fastInc[%d] "CMD_TERMINATOR, key, gkey_FastInc);
    2798:	4b03      	ldr	r3, [pc, #12]	; (27a8 <onKeyPress+0x10>)
    279a:	4602      	mov	r2, r0
    279c:	681b      	ldr	r3, [r3, #0]
    279e:	4903      	ldr	r1, [pc, #12]	; (27ac <onKeyPress+0x14>)
    27a0:	2001      	movs	r0, #1
    27a2:	f001 bb55 	b.w	3e50 <rprintf>
    27a6:	bf00      	nop
    27a8:	100005e8 	.word	0x100005e8
    27ac:	00004ef2 	.word	0x00004ef2

Disassembly of section .text.onKeyUp:

000027b0 <onKeyUp>:
}

void onKeyUp(char key __attribute__ ((unused)) ) {
	lprintf("onKeyUp key [0x%x] fastInc[%d] "CMD_TERMINATOR, key, gkey_FastInc);
    27b0:	4b03      	ldr	r3, [pc, #12]	; (27c0 <onKeyUp+0x10>)
    27b2:	4602      	mov	r2, r0
    27b4:	681b      	ldr	r3, [r3, #0]
    27b6:	4903      	ldr	r1, [pc, #12]	; (27c4 <onKeyUp+0x14>)
    27b8:	2001      	movs	r0, #1
    27ba:	f001 bb49 	b.w	3e50 <rprintf>
    27be:	bf00      	nop
    27c0:	100005e8 	.word	0x100005e8
    27c4:	00004f16 	.word	0x00004f16

Disassembly of section .text.relay_Init:

000027c8 <relay_Init>:

// #######################################################################################################
// RELAYS
// #######################################################################################################
void relay_Init(void) {
	relay1_Init();
    27c8:	4b07      	ldr	r3, [pc, #28]	; (27e8 <relay_Init+0x20>)
    27ca:	681a      	ldr	r2, [r3, #0]
    27cc:	f042 4280 	orr.w	r2, r2, #1073741824	; 0x40000000
    27d0:	601a      	str	r2, [r3, #0]
	relay2_Init();
    27d2:	681a      	ldr	r2, [r3, #0]
    27d4:	f042 4200 	orr.w	r2, r2, #2147483648	; 0x80000000
    27d8:	601a      	str	r2, [r3, #0]

	control.relay1.st = 0;
    27da:	4b04      	ldr	r3, [pc, #16]	; (27ec <relay_Init+0x24>)
    27dc:	2200      	movs	r2, #0
	control.relay1.timeout = 0;
    27de:	615a      	str	r2, [r3, #20]
// #######################################################################################################
void relay_Init(void) {
	relay1_Init();
	relay2_Init();

	control.relay1.st = 0;
    27e0:	611a      	str	r2, [r3, #16]
	control.relay1.timeout = 0;

	control.relay2.st = 0;
    27e2:	619a      	str	r2, [r3, #24]
	control.relay2.timeout = 0;
    27e4:	61da      	str	r2, [r3, #28]
    27e6:	4770      	bx	lr
    27e8:	2009c020 	.word	0x2009c020
    27ec:	100005ac 	.word	0x100005ac

Disassembly of section .text.relay_Set:

000027f0 <relay_Set>:
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    27f0:	2801      	cmp	r0, #1
// Liga ou desliga o rele
//	parametro rly: sinaliza qual o rele vamos acessar. valor 0 ou 1
//	parametro st: pdON liga o rele e pdOFF desliga o rele;
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
    27f2:	b510      	push	{r4, lr}
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    27f4:	d80d      	bhi.n	2812 <relay_Set+0x22>
	if (rly == 0) rl = &control.relay1; else rl = &control.relay2;
    27f6:	4b08      	ldr	r3, [pc, #32]	; (2818 <relay_Set+0x28>)
    27f8:	f103 0408 	add.w	r4, r3, #8
    27fc:	2800      	cmp	r0, #0
    27fe:	bf0c      	ite	eq
    2800:	4618      	moveq	r0, r3
    2802:	4620      	movne	r0, r4

	rl->timeout = timeout*1000;
    2804:	f44f 737a 	mov.w	r3, #1000	; 0x3e8
    2808:	435a      	muls	r2, r3
	rl->st = st;
    280a:	6001      	str	r1, [r0, #0]
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
	if (rly == 0) rl = &control.relay1; else rl = &control.relay2;

	rl->timeout = timeout*1000;
    280c:	6042      	str	r2, [r0, #4]
	rl->st = st;

	return pdPASS;
    280e:	2001      	movs	r0, #1
    2810:	bd10      	pop	{r4, pc}
//	parametro timeout: O tempo em segundos que o rele vai ficar no estado atual e voltar para o estado inverso
//		Se colocar valor 0, permanece no estado atual até o próximo comando
int relay_Set(int rly, int st, uint timeout) {
	pRelay rl;

	if ( (rly < 0) || (rly > 1) ) return errDEVICE_NOT_FOUND;
    2812:	4802      	ldr	r0, [pc, #8]	; (281c <relay_Set+0x2c>)

	rl->timeout = timeout*1000;
	rl->st = st;

	return pdPASS;
}
    2814:	bd10      	pop	{r4, pc}
    2816:	bf00      	nop
    2818:	100005bc 	.word	0x100005bc
    281c:	fffffed4 	.word	0xfffffed4

Disassembly of section .text.relay_Tick:

00002820 <relay_Tick>:

void relay_Tick(void) {
	if (control.relay1.st) relay1_On(); else relay1_Off();
    2820:	4b16      	ldr	r3, [pc, #88]	; (287c <relay_Tick+0x5c>)
	rl->st = st;

	return pdPASS;
}

void relay_Tick(void) {
    2822:	b510      	push	{r4, lr}
	if (control.relay1.st) relay1_On(); else relay1_Off();
    2824:	6919      	ldr	r1, [r3, #16]
    2826:	f04f 4280 	mov.w	r2, #1073741824	; 0x40000000
    282a:	b109      	cbz	r1, 2830 <relay_Tick+0x10>
    282c:	4814      	ldr	r0, [pc, #80]	; (2880 <relay_Tick+0x60>)
    282e:	e000      	b.n	2832 <relay_Tick+0x12>
    2830:	4814      	ldr	r0, [pc, #80]	; (2884 <relay_Tick+0x64>)
    2832:	6002      	str	r2, [r0, #0]
	if (control.relay2.st) relay2_On(); else relay2_Off();
    2834:	699a      	ldr	r2, [r3, #24]
    2836:	f04f 4000 	mov.w	r0, #2147483648	; 0x80000000
    283a:	b10a      	cbz	r2, 2840 <relay_Tick+0x20>
    283c:	4c10      	ldr	r4, [pc, #64]	; (2880 <relay_Tick+0x60>)
    283e:	e000      	b.n	2842 <relay_Tick+0x22>
    2840:	4c10      	ldr	r4, [pc, #64]	; (2884 <relay_Tick+0x64>)
    2842:	6020      	str	r0, [r4, #0]
	if (control.relay1.timeout > 0) control.relay1.timeout--;
    2844:	6958      	ldr	r0, [r3, #20]
    2846:	4c0d      	ldr	r4, [pc, #52]	; (287c <relay_Tick+0x5c>)
    2848:	b110      	cbz	r0, 2850 <relay_Tick+0x30>
    284a:	6960      	ldr	r0, [r4, #20]
    284c:	3801      	subs	r0, #1
    284e:	6160      	str	r0, [r4, #20]
	if (control.relay2.timeout > 0) control.relay2.timeout--;
    2850:	69d8      	ldr	r0, [r3, #28]
    2852:	4c0a      	ldr	r4, [pc, #40]	; (287c <relay_Tick+0x5c>)
    2854:	b110      	cbz	r0, 285c <relay_Tick+0x3c>
    2856:	69e0      	ldr	r0, [r4, #28]
    2858:	3801      	subs	r0, #1
    285a:	61e0      	str	r0, [r4, #28]
	//colocar depois do acionamento para que seja certinho a contagem dos tempos
	if (control.relay1.timeout == 1) control.relay1.st ^= 1;
    285c:	6958      	ldr	r0, [r3, #20]
	if (control.relay2.timeout == 1) control.relay2.st ^= 1;
    285e:	69db      	ldr	r3, [r3, #28]
	if (control.relay1.st) relay1_On(); else relay1_Off();
	if (control.relay2.st) relay2_On(); else relay2_Off();
	if (control.relay1.timeout > 0) control.relay1.timeout--;
	if (control.relay2.timeout > 0) control.relay2.timeout--;
	//colocar depois do acionamento para que seja certinho a contagem dos tempos
	if (control.relay1.timeout == 1) control.relay1.st ^= 1;
    2860:	2801      	cmp	r0, #1
    2862:	bf02      	ittt	eq
    2864:	4805      	ldreq	r0, [pc, #20]	; (287c <relay_Tick+0x5c>)
    2866:	f081 0101 	eoreq.w	r1, r1, #1
    286a:	6101      	streq	r1, [r0, #16]
	if (control.relay2.timeout == 1) control.relay2.st ^= 1;
    286c:	2b01      	cmp	r3, #1
    286e:	bf02      	ittt	eq
    2870:	4b02      	ldreq	r3, [pc, #8]	; (287c <relay_Tick+0x5c>)
    2872:	f082 0201 	eoreq.w	r2, r2, #1
    2876:	619a      	streq	r2, [r3, #24]
    2878:	bd10      	pop	{r4, pc}
    287a:	bf00      	nop
    287c:	100005ac 	.word	0x100005ac
    2880:	2009c038 	.word	0x2009c038
    2884:	2009c03c 	.word	0x2009c03c

Disassembly of section .text.app_Init:

00002888 <app_Init>:
}

// #######################################################################################################
// APPLICATION
// #######################################################################################################
void app_Init(void) {
    2888:	b508      	push	{r3, lr}
	control.action = pdFALSE;
    288a:	4b19      	ldr	r3, [pc, #100]	; (28f0 <app_Init+0x68>)
    288c:	781a      	ldrb	r2, [r3, #0]
	control.setTempStatics = pdFALSE;
	control.setTempType = pdFALSE;
    288e:	f002 02fc 	and.w	r2, r2, #252	; 0xfc
    2892:	f36f 0282 	bfc	r2, #2, #1
    2896:	701a      	strb	r2, [r3, #0]
	control.ticks = 0;
    2898:	2200      	movs	r2, #0
    289a:	609a      	str	r2, [r3, #8]
	control.key = 0;
	control.tempType = 0;
    289c:	605a      	str	r2, [r3, #4]
void app_Init(void) {
	control.action = pdFALSE;
	control.setTempStatics = pdFALSE;
	control.setTempType = pdFALSE;
	control.ticks = 0;
	control.key = 0;
    289e:	731a      	strb	r2, [r3, #12]
	control.tempType = 0;

	relay_Init();
    28a0:	f7ff ff92 	bl	27c8 <relay_Init>
	led1_Init();
    28a4:	4b13      	ldr	r3, [pc, #76]	; (28f4 <app_Init+0x6c>)
	led3_Init();
	led4_Init();
	led5_Init();
	led6_Init();

	modbus_Init(1); // Inicar o modbus master e slave com ID=1
    28a6:	2001      	movs	r0, #1
	control.ticks = 0;
	control.key = 0;
	control.tempType = 0;

	relay_Init();
	led1_Init();
    28a8:	681a      	ldr	r2, [r3, #0]
    28aa:	f042 0201 	orr.w	r2, r2, #1
    28ae:	601a      	str	r2, [r3, #0]
	led2_Init();
    28b0:	681a      	ldr	r2, [r3, #0]
    28b2:	f042 0202 	orr.w	r2, r2, #2
    28b6:	601a      	str	r2, [r3, #0]
	led3_Init();
    28b8:	f853 2c20 	ldr.w	r2, [r3, #-32]
    28bc:	f042 5280 	orr.w	r2, r2, #268435456	; 0x10000000
    28c0:	f843 2c20 	str.w	r2, [r3, #-32]
	led4_Init();
    28c4:	f853 2c20 	ldr.w	r2, [r3, #-32]
    28c8:	f042 5200 	orr.w	r2, r2, #536870912	; 0x20000000
    28cc:	f843 2c20 	str.w	r2, [r3, #-32]
	led5_Init();
    28d0:	f853 2c40 	ldr.w	r2, [r3, #-64]
    28d4:	f042 4280 	orr.w	r2, r2, #1073741824	; 0x40000000
    28d8:	f843 2c40 	str.w	r2, [r3, #-64]
	led6_Init();
    28dc:	f853 2c40 	ldr.w	r2, [r3, #-64]
    28e0:	f042 5200 	orr.w	r2, r2, #536870912	; 0x20000000
    28e4:	f843 2c40 	str.w	r2, [r3, #-64]

	modbus_Init(1); // Inicar o modbus master e slave com ID=1
}
    28e8:	e8bd 4008 	ldmia.w	sp!, {r3, lr}
	led3_Init();
	led4_Init();
	led5_Init();
	led6_Init();

	modbus_Init(1); // Inicar o modbus master e slave com ID=1
    28ec:	f000 bbc6 	b.w	307c <modbus_Init>
    28f0:	100005ac 	.word	0x100005ac
    28f4:	2009c040 	.word	0x2009c040

Disassembly of section .text.app_Tick:

000028f8 <app_Tick>:
}

// Aqui descre, ou chame, códigos que controlam tempos ou que sejam executados em tempos reguladores
void app_Tick(void) {
    28f8:	b570      	push	{r4, r5, r6, lr}
	// ATENÇÃO:  tempo de execução de TODOS os TICKS dentro dessa função NÃO pode ser superior a 1ms
	ledError_Tick();
    28fa:	f001 fbcb 	bl	4094 <ledError_Tick>
	beep_Tick();
    28fe:	f001 fced 	bl	42dc <beep_Tick>
	gKey_Tick();
    2902:	f001 fc21 	bl	4148 <gKey_Tick>
	relay_Tick();
    2906:	f7ff ff8b 	bl	2820 <relay_Tick>
	modbus_Tick();
    290a:	f000 fc29 	bl	3160 <modbus_Tick>

	// LEITURA DO TECLADO a cada 3ms
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
    290e:	4b1f      	ldr	r3, [pc, #124]	; (298c <app_Tick+0x94>)
    2910:	681a      	ldr	r2, [r3, #0]
    2912:	b112      	cbz	r2, 291a <app_Tick+0x22>
    2914:	681a      	ldr	r2, [r3, #0]
    2916:	3a01      	subs	r2, #1
    2918:	601a      	str	r2, [r3, #0]
	if (timeReadKey == 0) {
    291a:	681b      	ldr	r3, [r3, #0]
    291c:	4c1c      	ldr	r4, [pc, #112]	; (2990 <app_Tick+0x98>)
    291e:	2b00      	cmp	r3, #0
    2920:	d12f      	bne.n	2982 <app_Tick+0x8a>
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    2922:	481c      	ldr	r0, [pc, #112]	; (2994 <app_Tick+0x9c>)
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;
    2924:	4a19      	ldr	r2, [pc, #100]	; (298c <app_Tick+0x94>)

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    2926:	6801      	ldr	r1, [r0, #0]
	static volatile uint timeReadKey = 0;
	static int bufKey[3];
	static uint idx = 0;
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;
    2928:	2303      	movs	r3, #3
    292a:	6013      	str	r3, [r2, #0]

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    292c:	fbb1 f3f3 	udiv	r3, r1, r3
    2930:	4d19      	ldr	r5, [pc, #100]	; (2998 <app_Tick+0xa0>)
    2932:	eb03 0343 	add.w	r3, r3, r3, lsl #1
    2936:	1aca      	subs	r2, r1, r3
    2938:	682b      	ldr	r3, [r5, #0]
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
    293a:	682e      	ldr	r6, [r5, #0]
		bufKey[idx%3] |= (sw2_PIN&sw2_NUMPIN)?SW2:0;
    293c:	682d      	ldr	r5, [r5, #0]
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
    293e:	f416 2f00 	tst.w	r6, #524288	; 0x80000
    2942:	bf14      	ite	ne
    2944:	2602      	movne	r6, #2
    2946:	2600      	moveq	r6, #0
	if (timeReadKey) timeReadKey--;
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
    2948:	f3c3 4380 	ubfx	r3, r3, #18, #1
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
		bufKey[idx%3] |= (sw2_PIN&sw2_NUMPIN)?SW2:0;
    294c:	f415 1f80 	tst.w	r5, #1048576	; 0x100000
	if (timeReadKey == 0) {
		timeReadKey = 3;

		// fazer debounce no teclado
		bufKey[idx%3] = (sw0_PIN&sw0_NUMPIN)?SW0:0;
		bufKey[idx%3] |= (sw1_PIN&sw1_NUMPIN)?SW1:0;
    2950:	ea43 0306 	orr.w	r3, r3, r6
		bufKey[idx%3] |= (sw2_PIN&sw2_NUMPIN)?SW2:0;
    2954:	4d11      	ldr	r5, [pc, #68]	; (299c <app_Tick+0xa4>)
    2956:	bf14      	ite	ne
    2958:	2604      	movne	r6, #4
    295a:	2600      	moveq	r6, #0
    295c:	4333      	orrs	r3, r6
    295e:	f845 3022 	str.w	r3, [r5, r2, lsl #2]

		if ( (bufKey[0] == bufKey[1]) && (bufKey[1] == bufKey[2]) ) {
    2962:	682b      	ldr	r3, [r5, #0]
    2964:	686a      	ldr	r2, [r5, #4]
    2966:	4293      	cmp	r3, r2
    2968:	d105      	bne.n	2976 <app_Tick+0x7e>
    296a:	68aa      	ldr	r2, [r5, #8]
    296c:	4293      	cmp	r3, r2
			control.key = bufKey[2]&0x7; // para que não pegar o botão de reconfigure
    296e:	bf04      	itt	eq
    2970:	f003 0307 	andeq.w	r3, r3, #7
    2974:	7323      	strbeq	r3, [r4, #12]
		}
		if (idx == 2) idx = 0; else idx++;
    2976:	2902      	cmp	r1, #2
    2978:	bf0b      	itete	eq
    297a:	2300      	moveq	r3, #0
    297c:	3101      	addne	r1, #1
    297e:	6003      	streq	r3, [r0, #0]
    2980:	6001      	strne	r1, [r0, #0]
	}

	control.ticks++; // Contador de ticks do sistema
    2982:	68a3      	ldr	r3, [r4, #8]
    2984:	3301      	adds	r3, #1
    2986:	60a3      	str	r3, [r4, #8]
    2988:	bd70      	pop	{r4, r5, r6, pc}
    298a:	bf00      	nop
    298c:	100009f0 	.word	0x100009f0
    2990:	100005ac 	.word	0x100005ac
    2994:	100009ec 	.word	0x100009ec
    2998:	2009c034 	.word	0x2009c034
    299c:	100009f4 	.word	0x100009f4

Disassembly of section .text.app_Process:

000029a0 <app_Process>:
}


// Aqui descre, ou chame, códigos que não controlam tempos ou que não sejam executados em tempo reguladores, pelo menos diretamente
void app_Process(void) {
    29a0:	b570      	push	{r4, r5, r6, lr}
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
    29a2:	4c3d      	ldr	r4, [pc, #244]	; (2a98 <app_Process+0xf8>)
    29a4:	f44f 737a 	mov.w	r3, #1000	; 0x3e8
    29a8:	68a1      	ldr	r1, [r4, #8]
	control.ticks++; // Contador de ticks do sistema
}


// Aqui descre, ou chame, códigos que não controlam tempos ou que não sejam executados em tempo reguladores, pelo menos diretamente
void app_Process(void) {
    29aa:	b092      	sub	sp, #72	; 0x48
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
    29ac:	fbb1 f2f3 	udiv	r2, r1, r3
    29b0:	fb03 1312 	mls	r3, r3, r2, r1
    29b4:	2b00      	cmp	r3, #0
    29b6:	d16c      	bne.n	2a92 <app_Process+0xf2>
    29b8:	4b38      	ldr	r3, [pc, #224]	; (2a9c <app_Process+0xfc>)
    29ba:	68a1      	ldr	r1, [r4, #8]
    29bc:	681a      	ldr	r2, [r3, #0]
    29be:	4291      	cmp	r1, r2
    29c0:	d067      	beq.n	2a92 <app_Process+0xf2>
		ticks_d = control.ticks;
    29c2:	68a2      	ldr	r2, [r4, #8]
    29c4:	4d36      	ldr	r5, [pc, #216]	; (2aa0 <app_Process+0x100>)
    29c6:	601a      	str	r2, [r3, #0]
		if (ledpos==0x01) led1_On(); else led1_Off();
    29c8:	4a36      	ldr	r2, [pc, #216]	; (2aa4 <app_Process+0x104>)
    29ca:	4837      	ldr	r0, [pc, #220]	; (2aa8 <app_Process+0x108>)
    29cc:	6813      	ldr	r3, [r2, #0]
    29ce:	4937      	ldr	r1, [pc, #220]	; (2aac <app_Process+0x10c>)
    29d0:	2b01      	cmp	r3, #1
    29d2:	d102      	bne.n	29da <app_Process+0x3a>
    29d4:	4e36      	ldr	r6, [pc, #216]	; (2ab0 <app_Process+0x110>)
    29d6:	6033      	str	r3, [r6, #0]
    29d8:	e006      	b.n	29e8 <app_Process+0x48>
    29da:	2601      	movs	r6, #1
		if (ledpos==0x02) led2_On(); else led2_Off();
    29dc:	2b02      	cmp	r3, #2
void app_Process(void) {
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
    29de:	602e      	str	r6, [r5, #0]
		if (ledpos==0x02) led2_On(); else led2_Off();
    29e0:	d102      	bne.n	29e8 <app_Process+0x48>
    29e2:	4d33      	ldr	r5, [pc, #204]	; (2ab0 <app_Process+0x110>)
    29e4:	602b      	str	r3, [r5, #0]
    29e6:	e008      	b.n	29fa <app_Process+0x5a>
    29e8:	2602      	movs	r6, #2
		if (ledpos==0x04) led3_On(); else led3_Off();
    29ea:	2b04      	cmp	r3, #4
	static uint ledpos = 1;
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
    29ec:	602e      	str	r6, [r5, #0]
		if (ledpos==0x04) led3_On(); else led3_Off();
    29ee:	d104      	bne.n	29fa <app_Process+0x5a>
    29f0:	4d30      	ldr	r5, [pc, #192]	; (2ab4 <app_Process+0x114>)
    29f2:	f04f 5680 	mov.w	r6, #268435456	; 0x10000000
    29f6:	602e      	str	r6, [r5, #0]
    29f8:	e009      	b.n	2a0e <app_Process+0x6e>
    29fa:	f04f 5580 	mov.w	r5, #268435456	; 0x10000000
		if (ledpos==0x08) led4_On(); else led4_Off();
    29fe:	2b08      	cmp	r3, #8
	static uint ticks_d = 0;
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
    2a00:	6005      	str	r5, [r0, #0]
		if (ledpos==0x08) led4_On(); else led4_Off();
    2a02:	d104      	bne.n	2a0e <app_Process+0x6e>
    2a04:	482b      	ldr	r0, [pc, #172]	; (2ab4 <app_Process+0x114>)
    2a06:	f04f 5500 	mov.w	r5, #536870912	; 0x20000000
    2a0a:	6005      	str	r5, [r0, #0]
    2a0c:	e009      	b.n	2a22 <app_Process+0x82>
    2a0e:	f04f 5500 	mov.w	r5, #536870912	; 0x20000000
		if (ledpos==0x10) led5_On(); else led5_Off();
    2a12:	2b10      	cmp	r3, #16
	if ( (control.ticks%1000==0) && (control.ticks != ticks_d) ) {
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
		if (ledpos==0x08) led4_On(); else led4_Off();
    2a14:	6005      	str	r5, [r0, #0]
		if (ledpos==0x10) led5_On(); else led5_Off();
    2a16:	d104      	bne.n	2a22 <app_Process+0x82>
    2a18:	4827      	ldr	r0, [pc, #156]	; (2ab8 <app_Process+0x118>)
    2a1a:	f04f 4580 	mov.w	r5, #1073741824	; 0x40000000
    2a1e:	6005      	str	r5, [r0, #0]
    2a20:	e009      	b.n	2a36 <app_Process+0x96>
    2a22:	f04f 4080 	mov.w	r0, #1073741824	; 0x40000000
		if (ledpos==0x20) led6_On(); else led6_Off();
    2a26:	2b20      	cmp	r3, #32
		ticks_d = control.ticks;
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
		if (ledpos==0x08) led4_On(); else led4_Off();
		if (ledpos==0x10) led5_On(); else led5_Off();
    2a28:	6008      	str	r0, [r1, #0]
		if (ledpos==0x20) led6_On(); else led6_Off();
    2a2a:	d104      	bne.n	2a36 <app_Process+0x96>
    2a2c:	4b22      	ldr	r3, [pc, #136]	; (2ab8 <app_Process+0x118>)
    2a2e:	f04f 5100 	mov.w	r1, #536870912	; 0x20000000
    2a32:	6019      	str	r1, [r3, #0]
    2a34:	e006      	b.n	2a44 <app_Process+0xa4>
    2a36:	f04f 5000 	mov.w	r0, #536870912	; 0x20000000
		if (ledpos<0x20) ledpos<<=1; else ledpos=1;
    2a3a:	2b1f      	cmp	r3, #31
		if (ledpos==0x01) led1_On(); else led1_Off();
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
		if (ledpos==0x08) led4_On(); else led4_Off();
		if (ledpos==0x10) led5_On(); else led5_Off();
		if (ledpos==0x20) led6_On(); else led6_Off();
    2a3c:	6008      	str	r0, [r1, #0]
		if (ledpos<0x20) ledpos<<=1; else ledpos=1;
    2a3e:	d801      	bhi.n	2a44 <app_Process+0xa4>
    2a40:	005b      	lsls	r3, r3, #1
    2a42:	e000      	b.n	2a46 <app_Process+0xa6>
    2a44:	2301      	movs	r3, #1

		lcd_SetCursor(0, 0);
    2a46:	2100      	movs	r1, #0
    2a48:	4608      	mov	r0, r1
		if (ledpos==0x02) led2_On(); else led2_Off();
		if (ledpos==0x04) led3_On(); else led3_Off();
		if (ledpos==0x08) led4_On(); else led4_Off();
		if (ledpos==0x10) led5_On(); else led5_Off();
		if (ledpos==0x20) led6_On(); else led6_Off();
		if (ledpos<0x20) ledpos<<=1; else ledpos=1;
    2a4a:	6013      	str	r3, [r2, #0]

		lcd_SetCursor(0, 0);
    2a4c:	f001 fe40 	bl	46d0 <lcd_SetCursor>
		lcd_printf("ticks: %d secs", control.ticks/1000);
    2a50:	68a1      	ldr	r1, [r4, #8]
    2a52:	f44f 737a 	mov.w	r3, #1000	; 0x3e8
    2a56:	fbb1 f1f3 	udiv	r1, r1, r3
    2a5a:	4818      	ldr	r0, [pc, #96]	; (2abc <app_Process+0x11c>)
    2a5c:	f001 fec2 	bl	47e4 <lcd_printf>

		lcd_SetCursor(0, 1);
    2a60:	2101      	movs	r1, #1
    2a62:	2000      	movs	r0, #0
    2a64:	f001 fe34 	bl	46d0 <lcd_SetCursor>
		int integer, digit;
		string s;
		breakFloat(control.thermometer[0].value, &integer, &digit);
    2a68:	aa01      	add	r2, sp, #4
    2a6a:	4669      	mov	r1, sp
    2a6c:	6aa0      	ldr	r0, [r4, #40]	; 0x28
    2a6e:	f7ff fe3b 	bl	26e8 <breakFloat>
		stringFloat(s, integer, digit);
    2a72:	e89d 0006 	ldmia.w	sp, {r1, r2}
    2a76:	a802      	add	r0, sp, #8
    2a78:	f7ff fe52 	bl	2720 <stringFloat>
		lcd_printf("TEMP: %s%s", s, ((control.thermometer[0].sts&0x4)?"f":"c"));
    2a7c:	8ca3      	ldrh	r3, [r4, #36]	; 0x24
    2a7e:	4a10      	ldr	r2, [pc, #64]	; (2ac0 <app_Process+0x120>)
    2a80:	f013 0f04 	tst.w	r3, #4
    2a84:	4b0f      	ldr	r3, [pc, #60]	; (2ac4 <app_Process+0x124>)
    2a86:	a902      	add	r1, sp, #8
    2a88:	bf08      	it	eq
    2a8a:	461a      	moveq	r2, r3
    2a8c:	480e      	ldr	r0, [pc, #56]	; (2ac8 <app_Process+0x128>)
    2a8e:	f001 fea9 	bl	47e4 <lcd_printf>

	}
}
    2a92:	b012      	add	sp, #72	; 0x48
    2a94:	bd70      	pop	{r4, r5, r6, pc}
    2a96:	bf00      	nop
    2a98:	100005ac 	.word	0x100005ac
    2a9c:	10000a00 	.word	0x10000a00
    2aa0:	2009c05c 	.word	0x2009c05c
    2aa4:	10000000 	.word	0x10000000
    2aa8:	2009c03c 	.word	0x2009c03c
    2aac:	2009c01c 	.word	0x2009c01c
    2ab0:	2009c058 	.word	0x2009c058
    2ab4:	2009c038 	.word	0x2009c038
    2ab8:	2009c018 	.word	0x2009c018
    2abc:	00004f39 	.word	0x00004f39
    2ac0:	00004f37 	.word	0x00004f37
    2ac4:	00005433 	.word	0x00005433
    2ac8:	00004f48 	.word	0x00004f48

Disassembly of section .text.prompt_ClearTicks:

00002acc <prompt_ClearTicks>:

	return pdPASS;
}

static int prompt_ClearTicks(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	control.ticks = 0;
    2acc:	4b02      	ldr	r3, [pc, #8]	; (2ad8 <prompt_ClearTicks+0xc>)
    2ace:	2200      	movs	r2, #0
    2ad0:	609a      	str	r2, [r3, #8]
	return pdPASS;
}
    2ad2:	2001      	movs	r0, #1
    2ad4:	4770      	bx	lr
    2ad6:	bf00      	nop
    2ad8:	100005ac 	.word	0x100005ac

Disassembly of section .text.prompt_STS:

00002adc <prompt_STS>:
	temp_SetType(value);

	return pdPASS;
}

static int prompt_STS(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    2adc:	b570      	push	{r4, r5, r6, lr}
	lprintf(CMD_TERMINATOR);
    2ade:	4949      	ldr	r1, [pc, #292]	; (2c04 <prompt_STS+0x128>)
	temp_SetType(value);

	return pdPASS;
}

static int prompt_STS(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    2ae0:	b092      	sub	sp, #72	; 0x48
	lprintf(CMD_TERMINATOR);
    2ae2:	2001      	movs	r0, #1
    2ae4:	f001 f9b4 	bl	3e50 <rprintf>
	lprintf(CMD_TERMINATOR);
    2ae8:	4946      	ldr	r1, [pc, #280]	; (2c04 <prompt_STS+0x128>)
    2aea:	2001      	movs	r0, #1
    2aec:	f001 f9b0 	bl	3e50 <rprintf>
	lprintf("SYSTEM"CMD_TERMINATOR);
    2af0:	4945      	ldr	r1, [pc, #276]	; (2c08 <prompt_STS+0x12c>)
    2af2:	2001      	movs	r0, #1
    2af4:	f001 f9ac 	bl	3e50 <rprintf>
	lprintf("    "PROGAM_NAME);
	lprintf("    ucLibc version "__VERSION CMD_TERMINATOR);
	lprintf("    count TICKS: %u"CMD_TERMINATOR, control.ticks);
    2af8:	4c44      	ldr	r4, [pc, #272]	; (2c0c <prompt_STS+0x130>)

static int prompt_STS(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	lprintf(CMD_TERMINATOR);
	lprintf(CMD_TERMINATOR);
	lprintf("SYSTEM"CMD_TERMINATOR);
	lprintf("    "PROGAM_NAME);
    2afa:	4945      	ldr	r1, [pc, #276]	; (2c10 <prompt_STS+0x134>)
    2afc:	2001      	movs	r0, #1
    2afe:	f001 f9a7 	bl	3e50 <rprintf>
	lprintf("    ucLibc version "__VERSION CMD_TERMINATOR);
    2b02:	4944      	ldr	r1, [pc, #272]	; (2c14 <prompt_STS+0x138>)
    2b04:	2001      	movs	r0, #1
    2b06:	f001 f9a3 	bl	3e50 <rprintf>
	lprintf("    count TICKS: %u"CMD_TERMINATOR, control.ticks);
    2b0a:	68a2      	ldr	r2, [r4, #8]
    2b0c:	4942      	ldr	r1, [pc, #264]	; (2c18 <prompt_STS+0x13c>)
    2b0e:	2001      	movs	r0, #1
    2b10:	f001 f99e 	bl	3e50 <rprintf>
	lprintf("    key pressing: %u"CMD_TERMINATOR, control.key);
    2b14:	7b22      	ldrb	r2, [r4, #12]
    2b16:	4941      	ldr	r1, [pc, #260]	; (2c1c <prompt_STS+0x140>)
    2b18:	2001      	movs	r0, #1
    2b1a:	f001 f999 	bl	3e50 <rprintf>
	lprintf(CMD_TERMINATOR);
    2b1e:	4939      	ldr	r1, [pc, #228]	; (2c04 <prompt_STS+0x128>)
    2b20:	2001      	movs	r0, #1
    2b22:	f001 f995 	bl	3e50 <rprintf>

	lprintf(CMD_TERMINATOR);
    2b26:	4937      	ldr	r1, [pc, #220]	; (2c04 <prompt_STS+0x128>)
    2b28:	2001      	movs	r0, #1
    2b2a:	f001 f991 	bl	3e50 <rprintf>
	lprintf("THERMOMETERS"CMD_TERMINATOR);
    2b2e:	493c      	ldr	r1, [pc, #240]	; (2c20 <prompt_STS+0x144>)
    2b30:	2001      	movs	r0, #1
    2b32:	f001 f98d 	bl	3e50 <rprintf>
	uint x;
	int integer, digit;
	string s;

	for(x=0;x<nTHERMOMETER;x++) {
		if ( control.thermometer[x].stsCom == 5 ) {
    2b36:	6a23      	ldr	r3, [r4, #32]
			lprintf("   device[%d]:", x+1);
    2b38:	2201      	movs	r2, #1
	uint x;
	int integer, digit;
	string s;

	for(x=0;x<nTHERMOMETER;x++) {
		if ( control.thermometer[x].stsCom == 5 ) {
    2b3a:	2b05      	cmp	r3, #5
    2b3c:	d154      	bne.n	2be8 <prompt_STS+0x10c>
			lprintf("   device[%d]:", x+1);
    2b3e:	4939      	ldr	r1, [pc, #228]	; (2c24 <prompt_STS+0x148>)
    2b40:	4610      	mov	r0, r2
    2b42:	f001 f985 	bl	3e50 <rprintf>
    2b46:	8ca3      	ldrh	r3, [r4, #36]	; 0x24

			if ( (control.thermometer[x].sts & 0xf) == 0) lprintf(" sts=sensor reading"CMD_TERMINATOR);
    2b48:	f013 030f 	ands.w	r3, r3, #15
    2b4c:	d101      	bne.n	2b52 <prompt_STS+0x76>
    2b4e:	4936      	ldr	r1, [pc, #216]	; (2c28 <prompt_STS+0x14c>)
    2b50:	e002      	b.n	2b58 <prompt_STS+0x7c>
			else if ( (control.thermometer[x].sts & 0xf) == 2) lprintf(" sts=sensor error min"CMD_TERMINATOR);
    2b52:	2b02      	cmp	r3, #2
    2b54:	d104      	bne.n	2b60 <prompt_STS+0x84>
    2b56:	4935      	ldr	r1, [pc, #212]	; (2c2c <prompt_STS+0x150>)
    2b58:	2001      	movs	r0, #1
    2b5a:	f001 f979 	bl	3e50 <rprintf>
    2b5e:	e04d      	b.n	2bfc <prompt_STS+0x120>
			else if ( (control.thermometer[x].sts & 0xf) == 3) lprintf(" sts=sensor error max"CMD_TERMINATOR);
    2b60:	2b03      	cmp	r3, #3
    2b62:	d101      	bne.n	2b68 <prompt_STS+0x8c>
    2b64:	4932      	ldr	r1, [pc, #200]	; (2c30 <prompt_STS+0x154>)
    2b66:	e7f7      	b.n	2b58 <prompt_STS+0x7c>
			else {
				breakFloat(control.thermometer[x].value, &integer, &digit);
    2b68:	aa01      	add	r2, sp, #4
    2b6a:	4669      	mov	r1, sp
    2b6c:	6aa0      	ldr	r0, [r4, #40]	; 0x28
    2b6e:	f7ff fdbb 	bl	26e8 <breakFloat>
				stringFloat(s, integer, digit);
    2b72:	e89d 0006 	ldmia.w	sp, {r1, r2}
    2b76:	a802      	add	r0, sp, #8
    2b78:	f7ff fdd2 	bl	2720 <stringFloat>
				lprintf(" temperature [%s%s]", s, ((control.thermometer[x].sts&0x4)?"f":"c"));
    2b7c:	8ca3      	ldrh	r3, [r4, #36]	; 0x24
    2b7e:	4e2d      	ldr	r6, [pc, #180]	; (2c34 <prompt_STS+0x158>)
    2b80:	4d2d      	ldr	r5, [pc, #180]	; (2c38 <prompt_STS+0x15c>)
    2b82:	f013 0f04 	tst.w	r3, #4
    2b86:	bf14      	ite	ne
    2b88:	4633      	movne	r3, r6
    2b8a:	462b      	moveq	r3, r5
    2b8c:	aa02      	add	r2, sp, #8
    2b8e:	492b      	ldr	r1, [pc, #172]	; (2c3c <prompt_STS+0x160>)
    2b90:	2001      	movs	r0, #1
    2b92:	f001 f95d 	bl	3e50 <rprintf>

				breakFloat(control.thermometer[x].valueMin, &integer, &digit);
    2b96:	aa01      	add	r2, sp, #4
    2b98:	4669      	mov	r1, sp
    2b9a:	6ae0      	ldr	r0, [r4, #44]	; 0x2c
    2b9c:	f7ff fda4 	bl	26e8 <breakFloat>
				stringFloat(s, integer, digit);
    2ba0:	e89d 0006 	ldmia.w	sp, {r1, r2}
    2ba4:	a802      	add	r0, sp, #8
    2ba6:	f7ff fdbb 	bl	2720 <stringFloat>
				lprintf(" min [%s%s]", s, ((control.thermometer[x].sts&0x4)?"f":"c"));
    2baa:	8ca3      	ldrh	r3, [r4, #36]	; 0x24
    2bac:	aa02      	add	r2, sp, #8
    2bae:	f013 0f04 	tst.w	r3, #4
    2bb2:	bf14      	ite	ne
    2bb4:	4633      	movne	r3, r6
    2bb6:	462b      	moveq	r3, r5
    2bb8:	4921      	ldr	r1, [pc, #132]	; (2c40 <prompt_STS+0x164>)
    2bba:	2001      	movs	r0, #1
    2bbc:	f001 f948 	bl	3e50 <rprintf>

				breakFloat(control.thermometer[x].valueMax, &integer, &digit);
    2bc0:	aa01      	add	r2, sp, #4
    2bc2:	4669      	mov	r1, sp
    2bc4:	6b20      	ldr	r0, [r4, #48]	; 0x30
    2bc6:	f7ff fd8f 	bl	26e8 <breakFloat>
				stringFloat(s, integer, digit);
    2bca:	e89d 0006 	ldmia.w	sp, {r1, r2}
    2bce:	a802      	add	r0, sp, #8
    2bd0:	f7ff fda6 	bl	2720 <stringFloat>
				lprintf(" min [%s%s]"CMD_TERMINATOR, s, ((control.thermometer[x].sts&0x4)?"f":"c"));
    2bd4:	8ca3      	ldrh	r3, [r4, #36]	; 0x24
    2bd6:	aa02      	add	r2, sp, #8
    2bd8:	f013 0f04 	tst.w	r3, #4
    2bdc:	bf14      	ite	ne
    2bde:	4633      	movne	r3, r6
    2be0:	462b      	moveq	r3, r5
    2be2:	4918      	ldr	r1, [pc, #96]	; (2c44 <prompt_STS+0x168>)
    2be4:	2001      	movs	r0, #1
    2be6:	e007      	b.n	2bf8 <prompt_STS+0x11c>
			}
		} else if ( control.thermometer[x].stsCom == 0 )
    2be8:	b923      	cbnz	r3, 2bf4 <prompt_STS+0x118>
			lprintf("   device[%d]: No Communication"CMD_TERMINATOR, x+1);
    2bea:	4917      	ldr	r1, [pc, #92]	; (2c48 <prompt_STS+0x16c>)
    2bec:	4610      	mov	r0, r2
    2bee:	f001 f92f 	bl	3e50 <rprintf>
    2bf2:	e003      	b.n	2bfc <prompt_STS+0x120>
		else
			lprintf("   device[%d]: Error communication 0x%x"CMD_TERMINATOR, x+1, control.thermometer[x].stsCom);
    2bf4:	4610      	mov	r0, r2
    2bf6:	4915      	ldr	r1, [pc, #84]	; (2c4c <prompt_STS+0x170>)
    2bf8:	f001 f92a 	bl	3e50 <rprintf>
	}

	return pdPASS;
}
    2bfc:	2001      	movs	r0, #1
    2bfe:	b012      	add	sp, #72	; 0x48
    2c00:	bd70      	pop	{r4, r5, r6, pc}
    2c02:	bf00      	nop
    2c04:	00004f35 	.word	0x00004f35
    2c08:	00005008 	.word	0x00005008
    2c0c:	100005ac 	.word	0x100005ac
    2c10:	00005010 	.word	0x00005010
    2c14:	00005054 	.word	0x00005054
    2c18:	0000506c 	.word	0x0000506c
    2c1c:	00005081 	.word	0x00005081
    2c20:	00005097 	.word	0x00005097
    2c24:	000050a5 	.word	0x000050a5
    2c28:	000050b4 	.word	0x000050b4
    2c2c:	000050c9 	.word	0x000050c9
    2c30:	000050e0 	.word	0x000050e0
    2c34:	00004f37 	.word	0x00004f37
    2c38:	00005433 	.word	0x00005433
    2c3c:	000050f7 	.word	0x000050f7
    2c40:	0000510b 	.word	0x0000510b
    2c44:	00005117 	.word	0x00005117
    2c48:	00005124 	.word	0x00005124
    2c4c:	00005145 	.word	0x00005145

Disassembly of section .text.prompt_Dump:

00002c50 <prompt_Dump>:
static int prompt_ClearTicks(int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	control.ticks = 0;
	return pdPASS;
}

static int prompt_Dump (int argc __attribute__ ((unused)), portCHAR **argv ) {
    2c50:	b5f7      	push	{r0, r1, r2, r4, r5, r6, r7, lr}
    2c52:	460c      	mov	r4, r1
	long p1, p2;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2c54:	4669      	mov	r1, sp
    2c56:	4620      	mov	r0, r4
    2c58:	f001 f9bc 	bl	3fd4 <xatoi>
    2c5c:	b908      	cbnz	r0, 2c62 <prompt_Dump+0x12>
    2c5e:	2000      	movs	r0, #0
    2c60:	e039      	b.n	2cd6 <prompt_Dump+0x86>
	if (!xatoi(&argv[1], &p2)) return pdFAIL;
    2c62:	a901      	add	r1, sp, #4
    2c64:	1d20      	adds	r0, r4, #4
    2c66:	f001 f9b5 	bl	3fd4 <xatoi>
    2c6a:	2800      	cmp	r0, #0
    2c6c:	d0f7      	beq.n	2c5e <prompt_Dump+0xe>

	if (p1 < 0) p1 = 0;
    2c6e:	9b00      	ldr	r3, [sp, #0]
    2c70:	2b00      	cmp	r3, #0
    2c72:	bfbc      	itt	lt
    2c74:	2300      	movlt	r3, #0
    2c76:	9300      	strlt	r3, [sp, #0]
	if (p2 < 1) p2 = 256;
    2c78:	9b01      	ldr	r3, [sp, #4]

	u8 *ptr = (u8*) p1;
    2c7a:	9d00      	ldr	r5, [sp, #0]

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (!xatoi(&argv[1], &p2)) return pdFAIL;

	if (p1 < 0) p1 = 0;
	if (p2 < 1) p2 = 256;
    2c7c:	2b00      	cmp	r3, #0
    2c7e:	bfdc      	itt	le
    2c80:	f44f 7380 	movle.w	r3, #256	; 0x100
    2c84:	9301      	strle	r3, [sp, #4]

	u8 *ptr = (u8*) p1;
	u16 qtd_rd = p2;
    2c86:	f8bd 4004 	ldrh.w	r4, [sp, #4]

	while (qtd_rd) {
    2c8a:	b31c      	cbz	r4, 2cd4 <prompt_Dump+0x84>
  		if (qtd_rd >= 16)
    2c8c:	2c0f      	cmp	r4, #15
    2c8e:	d91a      	bls.n	2cc6 <prompt_Dump+0x76>
    2c90:	462e      	mov	r6, r5
    2c92:	192f      	adds	r7, r5, r4
    2c94:	b2bf      	uxth	r7, r7
  			// Enquanto o qtd_rd for maior que 15 faz, depois incrementea addr do buffer e da eeprom por 16, e decrementa qtd_rd por 16
  			for( ; qtd_rd>=16; ptr+=16, p1+=16, qtd_rd-=16 )
  				put_dump16(ptr, p1, 16, 16);
    2c96:	2310      	movs	r3, #16
    2c98:	461a      	mov	r2, r3
    2c9a:	4630      	mov	r0, r6
    2c9c:	9900      	ldr	r1, [sp, #0]
    2c9e:	f001 f94f 	bl	3f40 <put_dump16>
	u16 qtd_rd = p2;

	while (qtd_rd) {
  		if (qtd_rd >= 16)
  			// Enquanto o qtd_rd for maior que 15 faz, depois incrementea addr do buffer e da eeprom por 16, e decrementa qtd_rd por 16
  			for( ; qtd_rd>=16; ptr+=16, p1+=16, qtd_rd-=16 )
    2ca2:	9b00      	ldr	r3, [sp, #0]
    2ca4:	3610      	adds	r6, #16
    2ca6:	3310      	adds	r3, #16
    2ca8:	9300      	str	r3, [sp, #0]
    2caa:	1bbb      	subs	r3, r7, r6
    2cac:	b29b      	uxth	r3, r3
    2cae:	2b0f      	cmp	r3, #15
    2cb0:	d8f1      	bhi.n	2c96 <prompt_Dump+0x46>
    2cb2:	f1a4 0310 	sub.w	r3, r4, #16
    2cb6:	f3c3 130b 	ubfx	r3, r3, #4, #12
    2cba:	3301      	adds	r3, #1
  				put_dump16(ptr, p1, 16, 16);

		if (qtd_rd)
    2cbc:	f014 040f 	ands.w	r4, r4, #15
    2cc0:	eb05 1503 	add.w	r5, r5, r3, lsl #4
    2cc4:	d006      	beq.n	2cd4 <prompt_Dump+0x84>
			put_dump16(ptr, p1, qtd_rd, 16);
    2cc6:	2310      	movs	r3, #16
    2cc8:	4622      	mov	r2, r4
    2cca:	9900      	ldr	r1, [sp, #0]
    2ccc:	4628      	mov	r0, r5
    2cce:	f001 f937 	bl	3f40 <put_dump16>
    2cd2:	e7da      	b.n	2c8a <prompt_Dump+0x3a>
  	}

	return pdPASS;
    2cd4:	2001      	movs	r0, #1
}
    2cd6:	b003      	add	sp, #12
    2cd8:	bdf0      	pop	{r4, r5, r6, r7, pc}

Disassembly of section .text.prompt_Beep:

00002cda <prompt_Beep>:
  	} else result_prompt = pdPASS;

	return result_prompt;
}

static int prompt_Beep(int argc __attribute__ ((unused)), portCHAR **argv) {
    2cda:	b507      	push	{r0, r1, r2, lr}
    2cdc:	4608      	mov	r0, r1
	long p1;
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2cde:	a901      	add	r1, sp, #4
    2ce0:	f001 f978 	bl	3fd4 <xatoi>
    2ce4:	b118      	cbz	r0, 2cee <prompt_Beep+0x14>
	beep_Play(p1);
    2ce6:	9801      	ldr	r0, [sp, #4]
    2ce8:	f001 fae6 	bl	42b8 <beep_Play>
	return pdPASS;
    2cec:	2001      	movs	r0, #1
}
    2cee:	b003      	add	sp, #12
    2cf0:	f85d fb04 	ldr.w	pc, [sp], #4

Disassembly of section .text.prompt_SetTempType:

00002cf4 <prompt_SetTempType>:
	else temp_InitStatistic();

	return pdPASS;
}

static int prompt_SetTempType (int argc __attribute__ ((unused)), portCHAR **argv) {
    2cf4:	b570      	push	{r4, r5, r6, lr}
	if (control.action) { // se o recurso de hardware está fazendo uma ação com os termomentros não vamos executar o novo comando
    2cf6:	4b19      	ldr	r3, [pc, #100]	; (2d5c <prompt_SetTempType+0x68>)
	else temp_InitStatistic();

	return pdPASS;
}

static int prompt_SetTempType (int argc __attribute__ ((unused)), portCHAR **argv) {
    2cf8:	460e      	mov	r6, r1
	if (control.action) { // se o recurso de hardware está fazendo uma ação com os termomentros não vamos executar o novo comando
    2cfa:	781c      	ldrb	r4, [r3, #0]
    2cfc:	461d      	mov	r5, r3
    2cfe:	f014 0401 	ands.w	r4, r4, #1
    2d02:	d004      	beq.n	2d0e <prompt_SetTempType+0x1a>
	return pdPASS;
}

static int prompt_ResetSt (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
	if (control.action) // se o recurso de hardware está fazendo uma ação com os termomentros não vamos executar o novo comando
		lprintf("Can't run the command at the moment, because another command is in progress"CMD_TERMINATOR);
    2d04:	4916      	ldr	r1, [pc, #88]	; (2d60 <prompt_SetTempType+0x6c>)
    2d06:	2001      	movs	r0, #1
    2d08:	f001 f8a2 	bl	3e50 <rprintf>
    2d0c:	e024      	b.n	2d58 <prompt_SetTempType+0x64>
		return pdPASS;
	}

	uint value = 0;

	if (strcmp(argv[0], "c") == 0) {
    2d0e:	4915      	ldr	r1, [pc, #84]	; (2d64 <prompt_SetTempType+0x70>)
    2d10:	6830      	ldr	r0, [r6, #0]
    2d12:	f7fe f9cb 	bl	10ac <strcmp>
    2d16:	b920      	cbnz	r0, 2d22 <prompt_SetTempType+0x2e>
		value = 1;
		lprintf("Set temp to Celcius degree"CMD_TERMINATOR);
    2d18:	4913      	ldr	r1, [pc, #76]	; (2d68 <prompt_SetTempType+0x74>)
    2d1a:	2001      	movs	r0, #1
    2d1c:	f001 f898 	bl	3e50 <rprintf>
	}

	uint value = 0;

	if (strcmp(argv[0], "c") == 0) {
		value = 1;
    2d20:	2401      	movs	r4, #1
		lprintf("Set temp to Celcius degree"CMD_TERMINATOR);
	}

	if (strcmp(argv[0], "f") == 0) {
    2d22:	4912      	ldr	r1, [pc, #72]	; (2d6c <prompt_SetTempType+0x78>)
    2d24:	6830      	ldr	r0, [r6, #0]
    2d26:	f7fe f9c1 	bl	10ac <strcmp>
    2d2a:	b928      	cbnz	r0, 2d38 <prompt_SetTempType+0x44>
		value = 2;
		lprintf("Set temp to Fahrenheit degree"CMD_TERMINATOR);
    2d2c:	4910      	ldr	r1, [pc, #64]	; (2d70 <prompt_SetTempType+0x7c>)
    2d2e:	2001      	movs	r0, #1
    2d30:	f001 f88e 	bl	3e50 <rprintf>
		value = 1;
		lprintf("Set temp to Celcius degree"CMD_TERMINATOR);
	}

	if (strcmp(argv[0], "f") == 0) {
		value = 2;
    2d34:	2402      	movs	r4, #2
    2d36:	e00c      	b.n	2d52 <prompt_SetTempType+0x5e>
		lprintf("Set temp to Fahrenheit degree"CMD_TERMINATOR);
	}

	if (value == 0) {
    2d38:	b954      	cbnz	r4, 2d50 <prompt_SetTempType+0x5c>
		lprintf("Jump set to %s degree"CMD_TERMINATOR, (control.tempType == 0)?"Celcius":"Fahrenheit");
    2d3a:	6869      	ldr	r1, [r5, #4]
    2d3c:	4b0d      	ldr	r3, [pc, #52]	; (2d74 <prompt_SetTempType+0x80>)
    2d3e:	4a0e      	ldr	r2, [pc, #56]	; (2d78 <prompt_SetTempType+0x84>)
    2d40:	2001      	movs	r0, #1
    2d42:	2900      	cmp	r1, #0
    2d44:	bf18      	it	ne
    2d46:	461a      	movne	r2, r3
    2d48:	490c      	ldr	r1, [pc, #48]	; (2d7c <prompt_SetTempType+0x88>)
    2d4a:	f001 f881 	bl	3e50 <rprintf>
    2d4e:	e000      	b.n	2d52 <prompt_SetTempType+0x5e>
    2d50:	2401      	movs	r4, #1
	}

	temp_SetType(value);
    2d52:	4620      	mov	r0, r4
    2d54:	f7ff fcfc 	bl	2750 <temp_SetType>

	return pdPASS;
}
    2d58:	2001      	movs	r0, #1
    2d5a:	bd70      	pop	{r4, r5, r6, pc}
    2d5c:	100005ac 	.word	0x100005ac
    2d60:	00005181 	.word	0x00005181
    2d64:	00005433 	.word	0x00005433
    2d68:	000051ce 	.word	0x000051ce
    2d6c:	00004f37 	.word	0x00004f37
    2d70:	000051ea 	.word	0x000051ea
    2d74:	00005176 	.word	0x00005176
    2d78:	0000516e 	.word	0x0000516e
    2d7c:	00005209 	.word	0x00005209

Disassembly of section .text.prompt_Relay:

00002d80 <prompt_Relay>:
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	beep_Play(p1);
	return pdPASS;
}

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
    2d80:	b573      	push	{r0, r1, r4, r5, r6, lr}
    2d82:	460c      	mov	r4, r1
	long p1=0, p2=0, p3=0;
    2d84:	2300      	movs	r3, #0
	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	beep_Play(p1);
	return pdPASS;
}

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
    2d86:	4606      	mov	r6, r0
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2d88:	4669      	mov	r1, sp
    2d8a:	4620      	mov	r0, r4
	beep_Play(p1);
	return pdPASS;
}

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;
    2d8c:	9300      	str	r3, [sp, #0]
    2d8e:	9301      	str	r3, [sp, #4]

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
    2d90:	f001 f920 	bl	3fd4 <xatoi>
    2d94:	b908      	cbnz	r0, 2d9a <prompt_Relay+0x1a>
    2d96:	2000      	movs	r0, #0
    2d98:	e020      	b.n	2ddc <prompt_Relay+0x5c>
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
    2d9a:	4911      	ldr	r1, [pc, #68]	; (2de0 <prompt_Relay+0x60>)
    2d9c:	6860      	ldr	r0, [r4, #4]
    2d9e:	f7fe f985 	bl	10ac <strcmp>
    2da2:	fab0 f580 	clz	r5, r0
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    2da6:	2e02      	cmp	r6, #2

static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
    2da8:	ea4f 1555 	mov.w	r5, r5, lsr #5
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    2dac:	dc0d      	bgt.n	2dca <prompt_Relay+0x4a>

	int ret = relay_Set(p1-1, p2, p3);
    2dae:	9800      	ldr	r0, [sp, #0]
    2db0:	9a01      	ldr	r2, [sp, #4]
    2db2:	4629      	mov	r1, r5
    2db4:	3801      	subs	r0, #1
    2db6:	f7ff fd1b 	bl	27f0 <relay_Set>

	if (ret == errDEVICE_NOT_FOUND)
    2dba:	f510 7f96 	cmn.w	r0, #300	; 0x12c
    2dbe:	d10c      	bne.n	2dda <prompt_Relay+0x5a>
		lprintf("ERROR: relay must be 1 or 2"CMD_TERMINATOR);
    2dc0:	4908      	ldr	r1, [pc, #32]	; (2de4 <prompt_Relay+0x64>)
    2dc2:	2001      	movs	r0, #1
    2dc4:	f001 f844 	bl	3e50 <rprintf>
    2dc8:	e007      	b.n	2dda <prompt_Relay+0x5a>
static int prompt_Relay(int argc __attribute__ ((unused)), portCHAR **argv ) {
	long p1=0, p2=0, p3=0;

	if (!xatoi(&argv[0], &p1)) return pdFAIL;
	if (strcmp(argv[1], "on") == 0) p2=pdON; else p2=pdOFF;
	if (argc > 2) { if (!xatoi(&argv[2], &p3)) return pdFAIL; }
    2dca:	a901      	add	r1, sp, #4
    2dcc:	f104 0008 	add.w	r0, r4, #8
    2dd0:	f001 f900 	bl	3fd4 <xatoi>
    2dd4:	2800      	cmp	r0, #0
    2dd6:	d1ea      	bne.n	2dae <prompt_Relay+0x2e>
    2dd8:	e7dd      	b.n	2d96 <prompt_Relay+0x16>

	int ret = relay_Set(p1-1, p2, p3);

	if (ret == errDEVICE_NOT_FOUND)
		lprintf("ERROR: relay must be 1 or 2"CMD_TERMINATOR);
    2dda:	2001      	movs	r0, #1

	return pdPASS;
}
    2ddc:	b002      	add	sp, #8
    2dde:	bd70      	pop	{r4, r5, r6, pc}
    2de0:	00004c7a 	.word	0x00004c7a
    2de4:	00005220 	.word	0x00005220

Disassembly of section .text.prompt_ResetSt:

00002de8 <prompt_ResetSt>:
  	}

	return pdPASS;
}

static int prompt_ResetSt (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    2de8:	b508      	push	{r3, lr}
	if (control.action) // se o recurso de hardware está fazendo uma ação com os termomentros não vamos executar o novo comando
    2dea:	4b06      	ldr	r3, [pc, #24]	; (2e04 <prompt_ResetSt+0x1c>)
    2dec:	781b      	ldrb	r3, [r3, #0]
    2dee:	07db      	lsls	r3, r3, #31
    2df0:	d504      	bpl.n	2dfc <prompt_ResetSt+0x14>
		lprintf("Can't run the command at the moment, because another command is in progress"CMD_TERMINATOR);
    2df2:	4905      	ldr	r1, [pc, #20]	; (2e08 <prompt_ResetSt+0x20>)
    2df4:	2001      	movs	r0, #1
    2df6:	f001 f82b 	bl	3e50 <rprintf>
    2dfa:	e001      	b.n	2e00 <prompt_ResetSt+0x18>
	else temp_InitStatistic();
    2dfc:	f7ff fca0 	bl	2740 <temp_InitStatistic>

	return pdPASS;
}
    2e00:	2001      	movs	r0, #1
    2e02:	bd08      	pop	{r3, pc}
    2e04:	100005ac 	.word	0x100005ac
    2e08:	00005181 	.word	0x00005181

Disassembly of section .text.prompt_Process:

00002e0c <prompt_Process>:
	{ NULL, 0,  0, CMD_TYPE_FUNCTION,  	{ NULL },
			NULL,
			NULL },
};

void prompt_Process(void) {
    2e0c:	b570      	push	{r4, r5, r6, lr}
static portCHAR *argv_prompt [CLI_N_ARGS];
static int argc_prompt;

static int prompt_ProcessCommand(void) {
	// CAPTURA COMANDOS DO TERMINAL. SE TECLOU ENTER A FUNÇÃO RETORNA COM A QUANTIDADE DE CHAR DO COMANDO
	result_prompt = cli_GetLine (buffer_prompt, sizeof (buffer_prompt), PROMPT); // Chamo o console para entrada de comandos
    2e0e:	4a18      	ldr	r2, [pc, #96]	; (2e70 <prompt_Process+0x64>)
    2e10:	2128      	movs	r1, #40	; 0x28
    2e12:	4818      	ldr	r0, [pc, #96]	; (2e74 <prompt_Process+0x68>)
    2e14:	f001 faa8 	bl	4368 <cli_GetLine>
    2e18:	4c17      	ldr	r4, [pc, #92]	; (2e78 <prompt_Process+0x6c>)
    2e1a:	6020      	str	r0, [r4, #0]

	// CHECA FOI ENTRADO COM O COMANDO
	if (result_prompt) {	// checa se há entrada de comandos
    2e1c:	b198      	cbz	r0, 2e46 <prompt_Process+0x3a>
   		if (cli_ArgsParse ((char *) buffer_prompt, argv_prompt, sizeof (argv_prompt), &argc_prompt) == errCLI_EXED_ARGS) // Captura os endereços iniciais de cada argumento, contidos no comando, e grava nas posições do argv
    2e1e:	4e17      	ldr	r6, [pc, #92]	; (2e7c <prompt_Process+0x70>)
    2e20:	4d17      	ldr	r5, [pc, #92]	; (2e80 <prompt_Process+0x74>)
    2e22:	4633      	mov	r3, r6
    2e24:	2228      	movs	r2, #40	; 0x28
    2e26:	4629      	mov	r1, r5
    2e28:	4812      	ldr	r0, [pc, #72]	; (2e74 <prompt_Process+0x68>)
    2e2a:	f001 fb63 	bl	44f4 <cli_ArgsParse>
    2e2e:	f110 0f3c 	cmn.w	r0, #60	; 0x3c
    2e32:	d006      	beq.n	2e42 <prompt_Process+0x36>
   			result_prompt = errCLI_EXED_ARGS;
   		else if (argv_prompt[0])
    2e34:	682b      	ldr	r3, [r5, #0]
    2e36:	b143      	cbz	r3, 2e4a <prompt_Process+0x3e>
   			result_prompt = cli_ArgsDispatch(cli_list, argc_prompt, &argv_prompt[0]);							// Executa a função referente ao comando digitado
    2e38:	462a      	mov	r2, r5
    2e3a:	6831      	ldr	r1, [r6, #0]
    2e3c:	4811      	ldr	r0, [pc, #68]	; (2e84 <prompt_Process+0x78>)
    2e3e:	f001 fbd1 	bl	45e4 <cli_ArgsDispatch>
    2e42:	6020      	str	r0, [r4, #0]
    2e44:	e001      	b.n	2e4a <prompt_Process+0x3e>
  	} else result_prompt = pdPASS;
    2e46:	2301      	movs	r3, #1
    2e48:	6023      	str	r3, [r4, #0]
};

void prompt_Process(void) {
	static int resuslt;
	resuslt = prompt_ProcessCommand();
	switch (resuslt) {
    2e4a:	6823      	ldr	r3, [r4, #0]
    2e4c:	f113 0f3c 	cmn.w	r3, #60	; 0x3c
    2e50:	d004      	beq.n	2e5c <prompt_Process+0x50>
    2e52:	b12b      	cbz	r3, 2e60 <prompt_Process+0x54>
    2e54:	333f      	adds	r3, #63	; 0x3f
    2e56:	d109      	bne.n	2e6c <prompt_Process+0x60>
	case errCLI_EXED_ARGS:
		lprintf("System error"CMD_TERMINATOR);
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    2e58:	490b      	ldr	r1, [pc, #44]	; (2e88 <prompt_Process+0x7c>)
    2e5a:	e002      	b.n	2e62 <prompt_Process+0x56>
void prompt_Process(void) {
	static int resuslt;
	resuslt = prompt_ProcessCommand();
	switch (resuslt) {
	case errCLI_EXED_ARGS:
		lprintf("System error"CMD_TERMINATOR);
    2e5c:	490b      	ldr	r1, [pc, #44]	; (2e8c <prompt_Process+0x80>)
    2e5e:	e000      	b.n	2e62 <prompt_Process+0x56>
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    	break;
    case pdFAIL:
    	lprintf("Error in executing the command"CMD_TERMINATOR);
    2e60:	490b      	ldr	r1, [pc, #44]	; (2e90 <prompt_Process+0x84>)
    2e62:	2001      	movs	r0, #1
    	break;
    }
}
    2e64:	e8bd 4070 	ldmia.w	sp!, {r4, r5, r6, lr}
		break;
	case errCLI_CMD_NOT_FOUND:
		lprintf("Unknown command"CMD_TERMINATOR);
    	break;
    case pdFAIL:
    	lprintf("Error in executing the command"CMD_TERMINATOR);
    2e68:	f000 bff2 	b.w	3e50 <rprintf>
    2e6c:	bd70      	pop	{r4, r5, r6, pc}
    2e6e:	bf00      	nop
    2e70:	0000523d 	.word	0x0000523d
    2e74:	10000a34 	.word	0x10000a34
    2e78:	10000a08 	.word	0x10000a08
    2e7c:	10000a04 	.word	0x10000a04
    2e80:	10000a0c 	.word	0x10000a0c
    2e84:	00004f54 	.word	0x00004f54
    2e88:	0000524f 	.word	0x0000524f
    2e8c:	00005241 	.word	0x00005241
    2e90:	00005260 	.word	0x00005260

Disassembly of section .text.master_PutString:

00002e94 <master_PutString>:

// ##################################################################################################
// MASTER
// ##################################################################################################
static int master_PutString(u8* buffer, u16 count) {
	rs485_ENTXM_ON = rs485_ENTXM;
    2e94:	4b08      	ldr	r3, [pc, #32]	; (2eb8 <master_PutString+0x24>)
    2e96:	f44f 3200 	mov.w	r2, #131072	; 0x20000


// ##################################################################################################
// MASTER
// ##################################################################################################
static int master_PutString(u8* buffer, u16 count) {
    2e9a:	b510      	push	{r4, lr}
	rs485_ENTXM_ON = rs485_ENTXM;
    2e9c:	601a      	str	r2, [r3, #0]
	int ret = uartM_WriteTx(buffer, count);
    2e9e:	f7ff f945 	bl	212c <uart1_WriteTx>
    2ea2:	4604      	mov	r4, r0
	while (!uartM_EmptyTx()); // Vamos esperar que o serial envie a mensagem
    2ea4:	f7ff f936 	bl	2114 <uart1_EmptyTx>
    2ea8:	2800      	cmp	r0, #0
    2eaa:	d0fb      	beq.n	2ea4 <master_PutString+0x10>
	rs485_ENTXM_OFF = rs485_ENTXM;
    2eac:	4b03      	ldr	r3, [pc, #12]	; (2ebc <master_PutString+0x28>)
    2eae:	f44f 3200 	mov.w	r2, #131072	; 0x20000
    2eb2:	601a      	str	r2, [r3, #0]
	return ret;
}
    2eb4:	4620      	mov	r0, r4
    2eb6:	bd10      	pop	{r4, pc}
    2eb8:	2009c018 	.word	0x2009c018
    2ebc:	2009c01c 	.word	0x2009c01c

Disassembly of section .text.slave_PutString:

00002ec0 <slave_PutString>:

// ##################################################################################################
// SLAVE
// ##################################################################################################
static int slave_PutString (u8* buffer, u16 count) {
	rs485_ENTXS_ON = rs485_ENTXS;
    2ec0:	4b08      	ldr	r3, [pc, #32]	; (2ee4 <slave_PutString+0x24>)
    2ec2:	f04f 4280 	mov.w	r2, #1073741824	; 0x40000000
}

// ##################################################################################################
// SLAVE
// ##################################################################################################
static int slave_PutString (u8* buffer, u16 count) {
    2ec6:	b510      	push	{r4, lr}
	rs485_ENTXS_ON = rs485_ENTXS;
    2ec8:	601a      	str	r2, [r3, #0]
	int ret = uartS_WriteTx(buffer, count);
    2eca:	f7ff fb05 	bl	24d8 <uart3_WriteTx>
    2ece:	4604      	mov	r4, r0
	while (!uartS_EmptyTx()); // Vamos esperar que o serial envie a mensagem
    2ed0:	f7ff faf6 	bl	24c0 <uart3_EmptyTx>
    2ed4:	2800      	cmp	r0, #0
    2ed6:	d0fb      	beq.n	2ed0 <slave_PutString+0x10>
	rs485_ENTXS_OFF = rs485_ENTXS;
    2ed8:	4b03      	ldr	r3, [pc, #12]	; (2ee8 <slave_PutString+0x28>)
    2eda:	f04f 4280 	mov.w	r2, #1073741824	; 0x40000000
    2ede:	601a      	str	r2, [r3, #0]
	return ret;
}
    2ee0:	4620      	mov	r0, r4
    2ee2:	bd10      	pop	{r4, pc}
    2ee4:	2009c018 	.word	0x2009c018
    2ee8:	2009c01c 	.word	0x2009c01c

Disassembly of section .text.slave_ReadRegisters:

00002eec <slave_ReadRegisters>:
//					modbusSLAVE_DEVICE_FAILURE:	Um irrecuperável erro ocorreu enquanto o dispositivo estava tentando
//													executar a ação solicitada.
// -------------------------------------------------------------------------------------------------------------------
static int slave_ReadRegisters(uint addrInit, u8* query, uint count) {
	// checa se o endereço está dentro dos limite
	if ((count == 0) || (count > 120) ) return modbusILLEGAL_DATA_ADDRESS;
    2eec:	1e53      	subs	r3, r2, #1
    2eee:	2b77      	cmp	r3, #119	; 0x77
//					modbusILLEGAL_DATA_ADDRESS:	Endereço do registrador inexistente
//					modbusILLEGAL_DATA_VALUE:	Valor inválido
//					modbusSLAVE_DEVICE_FAILURE:	Um irrecuperável erro ocorreu enquanto o dispositivo estava tentando
//													executar a ação solicitada.
// -------------------------------------------------------------------------------------------------------------------
static int slave_ReadRegisters(uint addrInit, u8* query, uint count) {
    2ef0:	e92d 43f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, lr}
	// checa se o endereço está dentro dos limite
	if ((count == 0) || (count > 120) ) return modbusILLEGAL_DATA_ADDRESS;
    2ef4:	d854      	bhi.n	2fa0 <slave_ReadRegisters+0xb4>
		#if (LOG_MODBUS_SLAVE == pdON)
    	plognp("    [addrTherm=0x%x] [addrbase=0x%x]"CMD_TERMINATOR, addrTherm, addr);
    	#endif
	}

	switch (addr) {
    2ef6:	f240 4702 	movw	r7, #1026	; 0x402
    2efa:	f240 4e03 	movw	lr, #1027	; 0x403
    2efe:	f240 4c04 	movw	ip, #1028	; 0x404
    2f02:	f240 4801 	movw	r8, #1025	; 0x401
	// ---------------------------------------------------------------------------------------------------------------------------------------
	// REGISTRADORES DE TRABALHO
	case 0x10: *value = nTHERMOMETER; break;

	// Ler se há alguma ação em andamento, seja configuração de grandeza de temperatura; reset estatiticas ou o experimento
	case 0x11: *value = control.action; break;
    2f06:	4c31      	ldr	r4, [pc, #196]	; (2fcc <slave_ReadRegisters+0xe0>)
    2f08:	f5a0 6080 	sub.w	r0, r0, #1024	; 0x400
    2f0c:	eb01 0242 	add.w	r2, r1, r2, lsl #1
static int slave_GetValue(uint addr, u16* value) {
	int ret = 0;
	uint addrTherm = 0;

	if ( (addr >= 0x400) && (addr < 0x1000) ) {
		addrTherm = (uint)((addr-0x400)/5); 		// Encontrar o indice do termômetro no vetor de acordo com o addr
    2f10:	2605      	movs	r6, #5

	// ---------------------------------------------------------------------------------------------------------------------------------------
	// REGISTRADORES DOS TEMÔMETROS
	case 0x400: *value = control.thermometer[addrTherm].stsCom; break;
	case 0x401: *value = control.thermometer[addrTherm].sts; break;
	case 0x402: *value = control.thermometer[addrTherm].value; break;
    2f12:	251c      	movs	r5, #28
// -------------------------------------------------------------------------------------------------------------------
static int slave_GetValue(uint addr, u16* value) {
	int ret = 0;
	uint addrTherm = 0;

	if ( (addr >= 0x400) && (addr < 0x1000) ) {
    2f14:	f5b0 6f40 	cmp.w	r0, #3072	; 0xc00
		addrTherm = (uint)((addr-0x400)/5); 		// Encontrar o indice do termômetro no vetor de acordo com o addr
    2f18:	bf38      	it	cc
    2f1a:	fbb0 f3f6 	udivcc	r3, r0, r6
    2f1e:	f500 6980 	add.w	r9, r0, #1024	; 0x400
		addr = (uint)((addr-0x400)%5)+0x400; 		// Conveter para o endereço base para acesso
    2f22:	bf3d      	ittte	cc
    2f24:	eb03 0983 	addcc.w	r9, r3, r3, lsl #2
    2f28:	ebc9 0900 	rsbcc	r9, r9, r0
    2f2c:	f509 6980 	addcc.w	r9, r9, #1024	; 0x400
// Retorna:		0: Se a leitura foi feita com suscesso
//				-1: O endereço do registrador não existe (modbusILLEGAL_DATA_ADDRESS (02))
// -------------------------------------------------------------------------------------------------------------------
static int slave_GetValue(uint addr, u16* value) {
	int ret = 0;
	uint addrTherm = 0;
    2f30:	2300      	movcs	r3, #0
		#if (LOG_MODBUS_SLAVE == pdON)
    	plognp("    [addrTherm=0x%x] [addrbase=0x%x]"CMD_TERMINATOR, addrTherm, addr);
    	#endif
	}

	switch (addr) {
    2f32:	f1b9 0f11 	cmp.w	r9, #17
    2f36:	d023      	beq.n	2f80 <slave_ReadRegisters+0x94>
    2f38:	d80b      	bhi.n	2f52 <slave_ReadRegisters+0x66>
    2f3a:	f1b9 0f01 	cmp.w	r9, #1
    2f3e:	d01c      	beq.n	2f7a <slave_ReadRegisters+0x8e>
    2f40:	d331      	bcc.n	2fa6 <slave_ReadRegisters+0xba>
    2f42:	f1b9 0f02 	cmp.w	r9, #2
    2f46:	d031      	beq.n	2fac <slave_ReadRegisters+0xc0>
    2f48:	f1b9 0f10 	cmp.w	r9, #16
    2f4c:	d128      	bne.n	2fa0 <slave_ReadRegisters+0xb4>
	case 1:	*value = (MODEL[3] << 8) | MODEL[2]; break;
	case 2:	*value = (FIRMWARE_VERSION[2] << 8) | FIRMWARE_VERSION[0]; break;

	// ---------------------------------------------------------------------------------------------------------------------------------------
	// REGISTRADORES DE TRABALHO
	case 0x10: *value = nTHERMOMETER; break;
    2f4e:	2301      	movs	r3, #1
    2f50:	e02e      	b.n	2fb0 <slave_ReadRegisters+0xc4>
		#if (LOG_MODBUS_SLAVE == pdON)
    	plognp("    [addrTherm=0x%x] [addrbase=0x%x]"CMD_TERMINATOR, addrTherm, addr);
    	#endif
	}

	switch (addr) {
    2f52:	45b9      	cmp	r9, r7
    2f54:	d01c      	beq.n	2f90 <slave_ReadRegisters+0xa4>
    2f56:	d808      	bhi.n	2f6a <slave_ReadRegisters+0x7e>
    2f58:	f5b9 6f80 	cmp.w	r9, #1024	; 0x400
    2f5c:	d014      	beq.n	2f88 <slave_ReadRegisters+0x9c>
    2f5e:	45c1      	cmp	r9, r8
    2f60:	d11e      	bne.n	2fa0 <slave_ReadRegisters+0xb4>
	case 0x11: *value = control.action; break;

	// ---------------------------------------------------------------------------------------------------------------------------------------
	// REGISTRADORES DOS TEMÔMETROS
	case 0x400: *value = control.thermometer[addrTherm].stsCom; break;
	case 0x401: *value = control.thermometer[addrTherm].sts; break;
    2f62:	fb05 4303 	mla	r3, r5, r3, r4
    2f66:	8c9b      	ldrh	r3, [r3, #36]	; 0x24
    2f68:	e022      	b.n	2fb0 <slave_ReadRegisters+0xc4>
		#if (LOG_MODBUS_SLAVE == pdON)
    	plognp("    [addrTherm=0x%x] [addrbase=0x%x]"CMD_TERMINATOR, addrTherm, addr);
    	#endif
	}

	switch (addr) {
    2f6a:	45f1      	cmp	r9, lr
    2f6c:	d014      	beq.n	2f98 <slave_ReadRegisters+0xac>
    2f6e:	45e1      	cmp	r9, ip
    2f70:	d116      	bne.n	2fa0 <slave_ReadRegisters+0xb4>
	// REGISTRADORES DOS TEMÔMETROS
	case 0x400: *value = control.thermometer[addrTherm].stsCom; break;
	case 0x401: *value = control.thermometer[addrTherm].sts; break;
	case 0x402: *value = control.thermometer[addrTherm].value; break;
	case 0x403: *value = control.thermometer[addrTherm].valueMin; break;
	case 0x404: *value = control.thermometer[addrTherm].valueMax; break;
    2f72:	fb05 4303 	mla	r3, r5, r3, r4
    2f76:	8e1b      	ldrh	r3, [r3, #48]	; 0x30
    2f78:	e01a      	b.n	2fb0 <slave_ReadRegisters+0xc4>
	switch (addr) {

	// ---------------------------------------------------------------------------------------------------------------------------------------
	// ID
	case 0:	*value = (MODEL[1] << 8) | MODEL[0]; break;
	case 1:	*value = (MODEL[3] << 8) | MODEL[2]; break;
    2f7a:	f243 1330 	movw	r3, #12592	; 0x3130
    2f7e:	e017      	b.n	2fb0 <slave_ReadRegisters+0xc4>
	// ---------------------------------------------------------------------------------------------------------------------------------------
	// REGISTRADORES DE TRABALHO
	case 0x10: *value = nTHERMOMETER; break;

	// Ler se há alguma ação em andamento, seja configuração de grandeza de temperatura; reset estatiticas ou o experimento
	case 0x11: *value = control.action; break;
    2f80:	7823      	ldrb	r3, [r4, #0]
    2f82:	f003 0301 	and.w	r3, r3, #1
    2f86:	e013      	b.n	2fb0 <slave_ReadRegisters+0xc4>

	// ---------------------------------------------------------------------------------------------------------------------------------------
	// REGISTRADORES DOS TEMÔMETROS
	case 0x400: *value = control.thermometer[addrTherm].stsCom; break;
    2f88:	fb05 4303 	mla	r3, r5, r3, r4
    2f8c:	8c1b      	ldrh	r3, [r3, #32]
    2f8e:	e00f      	b.n	2fb0 <slave_ReadRegisters+0xc4>
	case 0x401: *value = control.thermometer[addrTherm].sts; break;
	case 0x402: *value = control.thermometer[addrTherm].value; break;
    2f90:	fb05 4303 	mla	r3, r5, r3, r4
    2f94:	8d1b      	ldrh	r3, [r3, #40]	; 0x28
    2f96:	e00b      	b.n	2fb0 <slave_ReadRegisters+0xc4>
	case 0x403: *value = control.thermometer[addrTherm].valueMin; break;
    2f98:	fb05 4303 	mla	r3, r5, r3, r4
    2f9c:	8d9b      	ldrh	r3, [r3, #44]	; 0x2c
    2f9e:	e007      	b.n	2fb0 <slave_ReadRegisters+0xc4>
	// preenche o buffer modbus com os valores dos registradores
	int ret;
	u16 value;
	uint i; for (i=0;i<count;i++) {
		ret = slave_GetValue(addrInit+i, &value);
		if (ret == -1) return modbusILLEGAL_DATA_ADDRESS;
    2fa0:	2002      	movs	r0, #2
    2fa2:	e8bd 83f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, pc}

	switch (addr) {

	// ---------------------------------------------------------------------------------------------------------------------------------------
	// ID
	case 0:	*value = (MODEL[1] << 8) | MODEL[0]; break;
    2fa6:	f247 2368 	movw	r3, #29288	; 0x7268
    2faa:	e001      	b.n	2fb0 <slave_ReadRegisters+0xc4>
	case 1:	*value = (MODEL[3] << 8) | MODEL[2]; break;
	case 2:	*value = (FIRMWARE_VERSION[2] << 8) | FIRMWARE_VERSION[0]; break;
    2fac:	f243 1331 	movw	r3, #12593	; 0x3131
	uint i; for (i=0;i<count;i++) {
		ret = slave_GetValue(addrInit+i, &value);
		if (ret == -1) return modbusILLEGAL_DATA_ADDRESS;
		else if (ret == -2) return modbusILLEGAL_DATA_VALUE;

		query[2*i] = (u8)(value>>8);
    2fb0:	ea4f 2913 	mov.w	r9, r3, lsr #8
    2fb4:	f881 9000 	strb.w	r9, [r1]
		query[2*i+1] = (u8)(value&0xFF);
    2fb8:	704b      	strb	r3, [r1, #1]
    2fba:	3102      	adds	r1, #2
	if ((count == 0) || (count > 120) ) return modbusILLEGAL_DATA_ADDRESS;

	// preenche o buffer modbus com os valores dos registradores
	int ret;
	u16 value;
	uint i; for (i=0;i<count;i++) {
    2fbc:	428a      	cmp	r2, r1
    2fbe:	f100 0001 	add.w	r0, r0, #1
    2fc2:	d1a7      	bne.n	2f14 <slave_ReadRegisters+0x28>
		#if (LOG_MODBUS_SLAVE == pdON)
    	plognp("MODBUS: [i=%d %d] [a=0x%x] [msb=0x%x %c] [lsb=0x%x %c]"CMD_TERMINATOR, i, count, addrInit+i, query[2*i], query[2*i], query[2*i+1], query[2*i+1]);
    	#endif
	}

	return modbusNO_ERROR; // retorna sinalizando que a operação ocorreu bem
    2fc4:	2000      	movs	r0, #0
}
    2fc6:	e8bd 83f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, pc}
    2fca:	bf00      	nop
    2fcc:	100005ac 	.word	0x100005ac

Disassembly of section .text.slave_SetValue:

00002fd0 <slave_SetValue>:
//				-3: No momento o dispositivo não pode gravar o valor, ou executar a tarefa (modbusSLAVE_DEVICE_FAILURE (4))
// -------------------------------------------------------------------------------------------------------------------
static int slave_SetValue(uint addr, u16 value) {
	int ret = 0;

	switch (addr) {
    2fd0:	2814      	cmp	r0, #20
// Retorna:		0: Se a gravação foi feita com suscesso
//				-1: O endereço do registrador não existe (modbusILLEGAL_DATA_ADDRESS (2))
// 				-2: Dado a ser gravado é inválido (modbusILLEGAL_DATA_VALUE (3))
//				-3: No momento o dispositivo não pode gravar o valor, ou executar a tarefa (modbusSLAVE_DEVICE_FAILURE (4))
// -------------------------------------------------------------------------------------------------------------------
static int slave_SetValue(uint addr, u16 value) {
    2fd2:	b510      	push	{r4, lr}
	int ret = 0;

	switch (addr) {
    2fd4:	d002      	beq.n	2fdc <slave_SetValue+0xc>
    2fd6:	2817      	cmp	r0, #23
    2fd8:	d009      	beq.n	2fee <slave_SetValue+0x1e>
    2fda:	e011      	b.n	3000 <slave_SetValue+0x30>
	//		0 = Tratamento da temperatura determinada pelo jumper do termômetro
	// 		1 = Configurar todos os termômetros a trabalhar com graus Celsius(0)
	//		2 = Configurar todos os termômetros a trabalhar com graus Fahrenheit(1)
	case 0x14:
		//if (control.action) return -3; // RERTIRADO PORQUE O PESSOAL DA UFSC NÃO ESTÁ SABENDO COMO TRATAR AS EXCEÇÕES NO SBC
		if (!control.action) temp_SetType(value);
    2fdc:	4b0c      	ldr	r3, [pc, #48]	; (3010 <slave_SetValue+0x40>)
    2fde:	781b      	ldrb	r3, [r3, #0]
    2fe0:	f013 0401 	ands.w	r4, r3, #1
    2fe4:	d10f      	bne.n	3006 <slave_SetValue+0x36>
    2fe6:	4608      	mov	r0, r1
    2fe8:	f7ff fbb2 	bl	2750 <temp_SetType>
    2fec:	e006      	b.n	2ffc <slave_SetValue+0x2c>
		break;

	// Reinicia as estatísticas de temperatura
	case 0x17:
		if (control.action) return -3; // se o recurso de hardware está fazendo uma ação com os termomentros não vamos executar o novo comando
    2fee:	4b08      	ldr	r3, [pc, #32]	; (3010 <slave_SetValue+0x40>)
    2ff0:	7818      	ldrb	r0, [r3, #0]
    2ff2:	f010 0401 	ands.w	r4, r0, #1
    2ff6:	d108      	bne.n	300a <slave_SetValue+0x3a>
		temp_InitStatistic();
    2ff8:	f7ff fba2 	bl	2740 <temp_InitStatistic>
//				-1: O endereço do registrador não existe (modbusILLEGAL_DATA_ADDRESS (2))
// 				-2: Dado a ser gravado é inválido (modbusILLEGAL_DATA_VALUE (3))
//				-3: No momento o dispositivo não pode gravar o valor, ou executar a tarefa (modbusSLAVE_DEVICE_FAILURE (4))
// -------------------------------------------------------------------------------------------------------------------
static int slave_SetValue(uint addr, u16 value) {
	int ret = 0;
    2ffc:	4620      	mov	r0, r4

	// Reinicia as estatísticas de temperatura
	case 0x17:
		if (control.action) return -3; // se o recurso de hardware está fazendo uma ação com os termomentros não vamos executar o novo comando
		temp_InitStatistic();
		break;
    2ffe:	bd10      	pop	{r4, pc}

	// ---------------------------------------------------------------------------------------------------------------------------------------
	// retorna sinalizando acesso em um registrador inválido
	default:
		ret = -1;
    3000:	f04f 30ff 	mov.w	r0, #4294967295
    3004:	bd10      	pop	{r4, pc}
	//		0 = Tratamento da temperatura determinada pelo jumper do termômetro
	// 		1 = Configurar todos os termômetros a trabalhar com graus Celsius(0)
	//		2 = Configurar todos os termômetros a trabalhar com graus Fahrenheit(1)
	case 0x14:
		//if (control.action) return -3; // RERTIRADO PORQUE O PESSOAL DA UFSC NÃO ESTÁ SABENDO COMO TRATAR AS EXCEÇÕES NO SBC
		if (!control.action) temp_SetType(value);
    3006:	2000      	movs	r0, #0
    3008:	bd10      	pop	{r4, pc}
		break;

	// Reinicia as estatísticas de temperatura
	case 0x17:
		if (control.action) return -3; // se o recurso de hardware está fazendo uma ação com os termomentros não vamos executar o novo comando
    300a:	f06f 0002 	mvn.w	r0, #2
	default:
		ret = -1;
	}

	return ret;
}
    300e:	bd10      	pop	{r4, pc}
    3010:	100005ac 	.word	0x100005ac

Disassembly of section .text.slave_WriteRegister:

00003014 <slave_WriteRegister>:
//					modbusILLEGAL_DATA_ADDRESS:	Endereço do registrador inexistente
//					modbusILLEGAL_DATA_VALUE:	Valor para escrita é inválido
//					modbusSLAVE_DEVICE_FAILURE:	Um irrecuperável erro ocorreu enquanto o dispositivo estava tentando
//													executar a ação solicitada.
// -------------------------------------------------------------------------------------------------------------------
static int slave_WriteRegister(uint addr, u16 value) {
    3014:	b508      	push	{r3, lr}

	#if (LOG_MODBUS_SLAVE == pdON)
    plognp("MODBUS: WRITE REG [a=0x%x] [val=0x%x]"CMD_TERMINATOR, addr, value);
    #endif

	ret = slave_SetValue(addr, value);
    3016:	f7ff ffdb 	bl	2fd0 <slave_SetValue>
	if (ret == -1) ret = modbusILLEGAL_DATA_ADDRESS;
    301a:	1c41      	adds	r1, r0, #1
    301c:	d006      	beq.n	302c <slave_WriteRegister+0x18>
	else if (ret == -2) ret = modbusILLEGAL_DATA_VALUE;
    301e:	1c82      	adds	r2, r0, #2
    3020:	d006      	beq.n	3030 <slave_WriteRegister+0x1c>
	else if (ret == -3) ret = modbusSLAVE_DEVICE_FAILURE;
    3022:	1cc3      	adds	r3, r0, #3
	else ret = modbusNO_ERROR; // retorna sinalizando que a operação ocorreu bem
    3024:	bf0c      	ite	eq
    3026:	2004      	moveq	r0, #4
    3028:	2000      	movne	r0, #0
    302a:	bd08      	pop	{r3, pc}
	#if (LOG_MODBUS_SLAVE == pdON)
    plognp("MODBUS: WRITE REG [a=0x%x] [val=0x%x]"CMD_TERMINATOR, addr, value);
    #endif

	ret = slave_SetValue(addr, value);
	if (ret == -1) ret = modbusILLEGAL_DATA_ADDRESS;
    302c:	2002      	movs	r0, #2
    302e:	bd08      	pop	{r3, pc}
	else if (ret == -2) ret = modbusILLEGAL_DATA_VALUE;
    3030:	2003      	movs	r0, #3
	else if (ret == -3) ret = modbusSLAVE_DEVICE_FAILURE;
	else ret = modbusNO_ERROR; // retorna sinalizando que a operação ocorreu bem

    return ret;
}
    3032:	bd08      	pop	{r3, pc}

Disassembly of section .text.slave_WriteRegisters:

00003034 <slave_WriteRegisters>:
//					modbusILLEGAL_DATA_ADDRESS:	Endereço do registrador inexistente
//					modbusILLEGAL_DATA_VALUE:	Valor para escrita é inválido
//					modbusSLAVE_DEVICE_FAILURE:	Um irrecuperável erro ocorreu enquanto o dispositivo estava tentando
//													executar a ação solicitada.
// -------------------------------------------------------------------------------------------------------------------
static int slave_WriteRegisters(uint addrInit, u8* query, uint count) {
    3034:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
	// checa se o endereço está dentro dos limite
	if ((count == 0) || (count > 120) ) return modbusILLEGAL_DATA_ADDRESS;
    3036:	1e53      	subs	r3, r2, #1
    3038:	2b77      	cmp	r3, #119	; 0x77
    303a:	d901      	bls.n	3040 <slave_WriteRegisters+0xc>
    303c:	2002      	movs	r0, #2
    303e:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    3040:	460d      	mov	r5, r1
    3042:	4604      	mov	r4, r0
    3044:	1816      	adds	r6, r2, r0
    3046:	eba1 0740 	sub.w	r7, r1, r0, lsl #1

	// salva os valores recebidos nos seus respectivos registradores
	int ret;
	uint i; for (i=0;i<count;i++) {
		ret = slave_SetValue(addrInit+i, (((u8)query[2*i]<<8) | query[2*i+1]));
    304a:	f817 1014 	ldrb.w	r1, [r7, r4, lsl #1]
    304e:	786b      	ldrb	r3, [r5, #1]
    3050:	4620      	mov	r0, r4
    3052:	ea43 2101 	orr.w	r1, r3, r1, lsl #8
    3056:	f7ff ffbb 	bl	2fd0 <slave_SetValue>
		if (ret == -1) return modbusILLEGAL_DATA_ADDRESS;
    305a:	1c42      	adds	r2, r0, #1
    305c:	d0ee      	beq.n	303c <slave_WriteRegisters+0x8>
		else if (ret == -2) return modbusILLEGAL_DATA_VALUE;
    305e:	1c83      	adds	r3, r0, #2
    3060:	d008      	beq.n	3074 <slave_WriteRegisters+0x40>
		else if (ret == -3) return modbusSLAVE_DEVICE_FAILURE;
    3062:	3003      	adds	r0, #3
    3064:	d008      	beq.n	3078 <slave_WriteRegisters+0x44>
    3066:	3401      	adds	r4, #1
	// checa se o endereço está dentro dos limite
	if ((count == 0) || (count > 120) ) return modbusILLEGAL_DATA_ADDRESS;

	// salva os valores recebidos nos seus respectivos registradores
	int ret;
	uint i; for (i=0;i<count;i++) {
    3068:	42a6      	cmp	r6, r4
    306a:	f105 0502 	add.w	r5, r5, #2
    306e:	d1ec      	bne.n	304a <slave_WriteRegisters+0x16>
		#if (LOG_MODBUS_SLAVE == pdON)
    	plognp("MODBUS: [a=0x%x] [v=0x%x]"CMD_TERMINATOR, addrInit, (((u8)query[2*i]<<8) | query[2*i+1]));
    	#endif
	}

	return modbusNO_ERROR; // retorna sinalizando que a operação ocorreu bem
    3070:	2000      	movs	r0, #0
    3072:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
	// salva os valores recebidos nos seus respectivos registradores
	int ret;
	uint i; for (i=0;i<count;i++) {
		ret = slave_SetValue(addrInit+i, (((u8)query[2*i]<<8) | query[2*i+1]));
		if (ret == -1) return modbusILLEGAL_DATA_ADDRESS;
		else if (ret == -2) return modbusILLEGAL_DATA_VALUE;
    3074:	2003      	movs	r0, #3
    3076:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
		else if (ret == -3) return modbusSLAVE_DEVICE_FAILURE;
    3078:	2004      	movs	r0, #4
    	plognp("MODBUS: [a=0x%x] [v=0x%x]"CMD_TERMINATOR, addrInit, (((u8)query[2*i]<<8) | query[2*i+1]));
    	#endif
	}

	return modbusNO_ERROR; // retorna sinalizando que a operação ocorreu bem
}
    307a:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}

Disassembly of section .text.modbus_Init:

0000307c <modbus_Init>:
static int slave_WriteRegister(uint addr, u16 value);
static int slave_WriteRegisters(uint addrInit, u8* query, uint count);

static int master_PutString(u8* buffer, u16 count);

void modbus_Init(uint id) {
    307c:	b537      	push	{r0, r1, r2, r4, r5, lr}
	// SLAVE
	modbus_SlaveInit(id, slave_PutString, uartS_GetChar, uartS_BufferQtdRx, uartS_ClearBufferRx);
    307e:	4b18      	ldr	r3, [pc, #96]	; (30e0 <modbus_Init+0x64>)
	modbus_SlaveAppendFunctions(slave_ReadRegisters, slave_WriteRegister, slave_WriteRegisters);
	rs485_ENTXS_DIR |= rs485_ENTXS;
    3080:	4c18      	ldr	r4, [pc, #96]	; (30e4 <modbus_Init+0x68>)

static int master_PutString(u8* buffer, u16 count);

void modbus_Init(uint id) {
	// SLAVE
	modbus_SlaveInit(id, slave_PutString, uartS_GetChar, uartS_BufferQtdRx, uartS_ClearBufferRx);
    3082:	9300      	str	r3, [sp, #0]
    3084:	4a18      	ldr	r2, [pc, #96]	; (30e8 <modbus_Init+0x6c>)
    3086:	4b19      	ldr	r3, [pc, #100]	; (30ec <modbus_Init+0x70>)
    3088:	4919      	ldr	r1, [pc, #100]	; (30f0 <modbus_Init+0x74>)
    308a:	f000 fb25 	bl	36d8 <modbus_SlaveInit>
	modbus_SlaveAppendFunctions(slave_ReadRegisters, slave_WriteRegister, slave_WriteRegisters);
    308e:	4a19      	ldr	r2, [pc, #100]	; (30f4 <modbus_Init+0x78>)
    3090:	4919      	ldr	r1, [pc, #100]	; (30f8 <modbus_Init+0x7c>)
    3092:	481a      	ldr	r0, [pc, #104]	; (30fc <modbus_Init+0x80>)
    3094:	f000 fb34 	bl	3700 <modbus_SlaveAppendFunctions>
	rs485_ENTXS_DIR |= rs485_ENTXS;
    3098:	6823      	ldr	r3, [r4, #0]
	rs485_ENTXS_OFF = rs485_ENTXS;
    309a:	4d19      	ldr	r5, [pc, #100]	; (3100 <modbus_Init+0x84>)

void modbus_Init(uint id) {
	// SLAVE
	modbus_SlaveInit(id, slave_PutString, uartS_GetChar, uartS_BufferQtdRx, uartS_ClearBufferRx);
	modbus_SlaveAppendFunctions(slave_ReadRegisters, slave_WriteRegister, slave_WriteRegisters);
	rs485_ENTXS_DIR |= rs485_ENTXS;
    309c:	f043 4380 	orr.w	r3, r3, #1073741824	; 0x40000000
    30a0:	6023      	str	r3, [r4, #0]
	rs485_ENTXS_OFF = rs485_ENTXS;
    30a2:	f04f 4380 	mov.w	r3, #1073741824	; 0x40000000
    30a6:	602b      	str	r3, [r5, #0]
	uartS_Init(BAUDRATE_RASPBERRY);
    30a8:	f44f 4061 	mov.w	r0, #57600	; 0xe100
    30ac:	f7ff f926 	bl	22fc <uart3_Init>

	// MASTER
	modbus_MasterInit(master_PutString, uartM_GetChar, uartM_ClearBufferRx);
    30b0:	4a14      	ldr	r2, [pc, #80]	; (3104 <modbus_Init+0x88>)
    30b2:	4915      	ldr	r1, [pc, #84]	; (3108 <modbus_Init+0x8c>)
    30b4:	4815      	ldr	r0, [pc, #84]	; (310c <modbus_Init+0x90>)
    30b6:	f000 f965 	bl	3384 <modbus_MasterInit>
	modbus_MasterTimeout(3000);
    30ba:	f640 30b8 	movw	r0, #3000	; 0xbb8
    30be:	f000 f97b 	bl	33b8 <modbus_MasterTimeout>
	rs485_ENTXM_DIR |= rs485_ENTXM;
    30c2:	6823      	ldr	r3, [r4, #0]
	rs485_ENTXM_OFF = rs485_ENTXM;
	uartM_Init(BAUDRATE_THERMOMETER);
    30c4:	f44f 4061 	mov.w	r0, #57600	; 0xe100
	uartS_Init(BAUDRATE_RASPBERRY);

	// MASTER
	modbus_MasterInit(master_PutString, uartM_GetChar, uartM_ClearBufferRx);
	modbus_MasterTimeout(3000);
	rs485_ENTXM_DIR |= rs485_ENTXM;
    30c8:	f443 3300 	orr.w	r3, r3, #131072	; 0x20000
    30cc:	6023      	str	r3, [r4, #0]
	rs485_ENTXM_OFF = rs485_ENTXM;
    30ce:	f44f 3300 	mov.w	r3, #131072	; 0x20000
    30d2:	602b      	str	r3, [r5, #0]
	uartM_Init(BAUDRATE_THERMOMETER);
}
    30d4:	b003      	add	sp, #12
    30d6:	e8bd 4030 	ldmia.w	sp!, {r4, r5, lr}
	// MASTER
	modbus_MasterInit(master_PutString, uartM_GetChar, uartM_ClearBufferRx);
	modbus_MasterTimeout(3000);
	rs485_ENTXM_DIR |= rs485_ENTXM;
	rs485_ENTXM_OFF = rs485_ENTXM;
	uartM_Init(BAUDRATE_THERMOMETER);
    30da:	f7fe bf33 	b.w	1f44 <uart1_Init>
    30de:	bf00      	nop
    30e0:	000023e9 	.word	0x000023e9
    30e4:	2009c000 	.word	0x2009c000
    30e8:	000023a5 	.word	0x000023a5
    30ec:	00002425 	.word	0x00002425
    30f0:	00002ec1 	.word	0x00002ec1
    30f4:	00003035 	.word	0x00003035
    30f8:	00003015 	.word	0x00003015
    30fc:	00002eed 	.word	0x00002eed
    3100:	2009c01c 	.word	0x2009c01c
    3104:	00002049 	.word	0x00002049
    3108:	00002005 	.word	0x00002005
    310c:	00002e95 	.word	0x00002e95

Disassembly of section .text.modbus_SendCommand:

00003110 <modbus_SendCommand>:
//	OK para Leitura: Capturar os valores dos registradores lidos do escravo
// Parâmetros:
// 		slaveID. Endereço do escravo a ser acessado
// 		c: Tipo de comando para ser enviado ao escravo
typedef enum {readREGS, writeREG, writeREGS} tcmd;
void modbus_SendCommand(uint slaveID, tCommand c, u16 value) {
    3110:	b538      	push	{r3, r4, r5, lr}
    if (waitResponse) return;
    3112:	4c10      	ldr	r4, [pc, #64]	; (3154 <modbus_SendCommand+0x44>)
    3114:	6823      	ldr	r3, [r4, #0]
    3116:	b9db      	cbnz	r3, 3150 <modbus_SendCommand+0x40>

	cmd = c;
    3118:	4d0f      	ldr	r5, [pc, #60]	; (3158 <modbus_SendCommand+0x48>)
    tcmd typeCMD = readREGS;
    uint addrInit = 0;
    uint nRegs = 3;

    // Comando para ler os valores dos sensores
    if (cmd == cmdSET_TEMPERATURE_TYPE) {
    311a:	2903      	cmp	r1, #3
// 		c: Tipo de comando para ser enviado ao escravo
typedef enum {readREGS, writeREG, writeREGS} tcmd;
void modbus_SendCommand(uint slaveID, tCommand c, u16 value) {
    if (waitResponse) return;

	cmd = c;
    311c:	7029      	strb	r1, [r5, #0]
    tcmd typeCMD = readREGS;
    uint addrInit = 0;
    uint nRegs = 3;

    // Comando para ler os valores dos sensores
    if (cmd == cmdSET_TEMPERATURE_TYPE) {
    311e:	d006      	beq.n	312e <modbus_SendCommand+0x1e>
        typeCMD = writeREG;
        addrInit = 0x20;
        nRegs = 1;
	}
	else if (cmd == cmdGET_TEMPERATURE) {
    3120:	2902      	cmp	r1, #2
    3122:	d00e      	beq.n	3142 <modbus_SendCommand+0x32>
        addrInit = 0x200;
        nRegs = 4;
	}
	else if (cmd == cmdRST_TEMPERATURE_STATISTIC) {
    3124:	2904      	cmp	r1, #4
    3126:	d004      	beq.n	3132 <modbus_SendCommand+0x22>
    // -----------------------------------------------------------------------------------------------------------------

    // Comando para ler os registradores: modelo, versão firmware e modo de operações dos reles
    tcmd typeCMD = readREGS;
    uint addrInit = 0;
    uint nRegs = 3;
    3128:	2203      	movs	r2, #3
    // APONTA QUAIS REGISTRADORES A ACESSAR NO DISPOSITIVO
    // -----------------------------------------------------------------------------------------------------------------

    // Comando para ler os registradores: modelo, versão firmware e modo de operações dos reles
    tcmd typeCMD = readREGS;
    uint addrInit = 0;
    312a:	4619      	mov	r1, r3
    312c:	e00c      	b.n	3148 <modbus_SendCommand+0x38>
    uint nRegs = 3;

    // Comando para ler os valores dos sensores
    if (cmd == cmdSET_TEMPERATURE_TYPE) {
        typeCMD = writeREG;
        addrInit = 0x20;
    312e:	2120      	movs	r1, #32
    3130:	e001      	b.n	3136 <modbus_SendCommand+0x26>
        addrInit = 0x200;
        nRegs = 4;
	}
	else if (cmd == cmdRST_TEMPERATURE_STATISTIC) {
        typeCMD = writeREG;
        addrInit = 0xA001;
    3132:	f24a 0101 	movw	r1, #40961	; 0xa001
   	int ret;
    if (typeCMD == writeREG) {
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("modbus WriteReg [slave %d] [reg 0x%x] [value 0x%x]"CMD_TERMINATOR, slaveID, addrInit, value);
    	#endif
		ret =  modbus_MasterWriteRegister(slaveID, addrInit, value);
    3136:	f000 f98f 	bl	3458 <modbus_MasterWriteRegister>
    	#endif
		ret = modbus_MasterReadRegisters(slaveID, addrInit, nRegs, regs);
	}

	// se foi enviado com sucesso ficaremos na espera da resposta do termômetro
	if (ret == pdPASS) waitResponse = pdTRUE;
    313a:	2801      	cmp	r0, #1
    313c:	d108      	bne.n	3150 <modbus_SendCommand+0x40>
    313e:	6020      	str	r0, [r4, #0]
    3140:	bd38      	pop	{r3, r4, r5, pc}
        addrInit = 0x20;
        nRegs = 1;
	}
	else if (cmd == cmdGET_TEMPERATURE) {
        addrInit = 0x200;
        nRegs = 4;
    3142:	2204      	movs	r2, #4
        typeCMD = writeREG;
        addrInit = 0x20;
        nRegs = 1;
	}
	else if (cmd == cmdGET_TEMPERATURE) {
        addrInit = 0x200;
    3144:	f44f 7100 	mov.w	r1, #512	; 0x200
        ret = modbus_MasterWriteRegisters(slaveID, addrInit, nRegs, regs);
    } else {
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("modbus ReadRegs [slave %d] [reg 0x%x] [len %d]"CMD_TERMINATOR, slaveID, addrInit, nRegs);
    	#endif
		ret = modbus_MasterReadRegisters(slaveID, addrInit, nRegs, regs);
    3148:	4b04      	ldr	r3, [pc, #16]	; (315c <modbus_SendCommand+0x4c>)
    314a:	f000 f947 	bl	33dc <modbus_MasterReadRegisters>
    314e:	e7f4      	b.n	313a <modbus_SendCommand+0x2a>
    3150:	bd38      	pop	{r3, r4, r5, pc}
    3152:	bf00      	nop
    3154:	10000a60 	.word	0x10000a60
    3158:	10000a5c 	.word	0x10000a5c
    315c:	10000a68 	.word	0x10000a68

Disassembly of section .text.modbus_Tick:

00003160 <modbus_Tick>:
	else plognp("modbus err[%d] send querie"CMD_TERMINATOR, modbus_MasterReadStatus());
    #endif
}


void modbus_Tick(void) {
    3160:	b508      	push	{r3, lr}
	modbus_MasterTick();
    3162:	f000 fa89 	bl	3678 <modbus_MasterTick>
	modbus_SlaveTick();
}
    3166:	e8bd 4008 	ldmia.w	sp!, {r3, lr}
}


void modbus_Tick(void) {
	modbus_MasterTick();
	modbus_SlaveTick();
    316a:	f000 bb87 	b.w	387c <modbus_SlaveTick>

Disassembly of section .text.modbus_Process:

00003170 <modbus_Process>:
}

static uint thermometerAccess = 1;
static uint triggerAction = 0;

void modbus_Process(void) {
    3170:	b570      	push	{r4, r5, r6, lr}
	modbus_SlaveProcess();
	modbus_MasterProcess();

	// se não estamos esperando a resposta do modbus_SendCommand anterior vamos analisar o próximo comando a ser enviado
	if (!waitResponse) {
    3172:	4c56      	ldr	r4, [pc, #344]	; (32cc <modbus_Process+0x15c>)

static uint thermometerAccess = 1;
static uint triggerAction = 0;

void modbus_Process(void) {
	modbus_SlaveProcess();
    3174:	f000 face 	bl	3714 <modbus_SlaveProcess>
	modbus_MasterProcess();
    3178:	f000 f9b0 	bl	34dc <modbus_MasterProcess>

	// se não estamos esperando a resposta do modbus_SendCommand anterior vamos analisar o próximo comando a ser enviado
	if (!waitResponse) {
    317c:	6822      	ldr	r2, [r4, #0]
    317e:	2a00      	cmp	r2, #0
    3180:	d14b      	bne.n	321a <modbus_Process+0xaa>
		tCommand cmdSend;
		u16 value = 0;
		int cmdConfig;
		if ( (control.setTempType) || (control.setTempStatics)) cmdConfig = pdTRUE; else cmdConfig = pdFALSE;
    3182:	4c53      	ldr	r4, [pc, #332]	; (32d0 <modbus_Process+0x160>)

		// aponta para o próximo termômetro
		if (thermometerAccess >= nTHERMOMETER) { // se chegamos no último termômetro vamos apontar para o primeiro
    3184:	4d53      	ldr	r5, [pc, #332]	; (32d4 <modbus_Process+0x164>)
	// se não estamos esperando a resposta do modbus_SendCommand anterior vamos analisar o próximo comando a ser enviado
	if (!waitResponse) {
		tCommand cmdSend;
		u16 value = 0;
		int cmdConfig;
		if ( (control.setTempType) || (control.setTempStatics)) cmdConfig = pdTRUE; else cmdConfig = pdFALSE;
    3186:	7823      	ldrb	r3, [r4, #0]

		// aponta para o próximo termômetro
		if (thermometerAccess >= nTHERMOMETER) { // se chegamos no último termômetro vamos apontar para o primeiro
    3188:	6828      	ldr	r0, [r5, #0]
	// se não estamos esperando a resposta do modbus_SendCommand anterior vamos analisar o próximo comando a ser enviado
	if (!waitResponse) {
		tCommand cmdSend;
		u16 value = 0;
		int cmdConfig;
		if ( (control.setTempType) || (control.setTempStatics)) cmdConfig = pdTRUE; else cmdConfig = pdFALSE;
    318a:	f003 0606 	and.w	r6, r3, #6
    318e:	2101      	movs	r1, #1

		// aponta para o próximo termômetro
		if (thermometerAccess >= nTHERMOMETER) { // se chegamos no último termômetro vamos apontar para o primeiro
    3190:	b190      	cbz	r0, 31b8 <modbus_Process+0x48>
			thermometerAccess = 1;
    3192:	6029      	str	r1, [r5, #0]

			// se foi algum comando de config dos termômetros vamos sinalizar que não tem mais configurações
			if ( cmdConfig ) {
    3194:	b146      	cbz	r6, 31a8 <modbus_Process+0x38>
				control.action = pdFALSE;
    3196:	f362 0300 	bfi	r3, r2, #0, #1
    319a:	7023      	strb	r3, [r4, #0]
				triggerAction = pdFALSE;
    319c:	4b4e      	ldr	r3, [pc, #312]	; (32d8 <modbus_Process+0x168>)
				#if (LOG_APP == pdON)
				plognp("Finish config"CMD_TERMINATOR);
    319e:	494f      	ldr	r1, [pc, #316]	; (32dc <modbus_Process+0x16c>)
    31a0:	2002      	movs	r0, #2
			thermometerAccess = 1;

			// se foi algum comando de config dos termômetros vamos sinalizar que não tem mais configurações
			if ( cmdConfig ) {
				control.action = pdFALSE;
				triggerAction = pdFALSE;
    31a2:	601a      	str	r2, [r3, #0]
				#if (LOG_APP == pdON)
				plognp("Finish config"CMD_TERMINATOR);
    31a4:	f000 fe54 	bl	3e50 <rprintf>
				#endif
			}
			control.setTempType = pdFALSE;
    31a8:	7823      	ldrb	r3, [r4, #0]
			control.setTempStatics = pdFALSE;
			cmdConfig = pdFALSE;
    31aa:	2600      	movs	r6, #0
				#if (LOG_APP == pdON)
				plognp("Finish config"CMD_TERMINATOR);
				#endif
			}
			control.setTempType = pdFALSE;
			control.setTempStatics = pdFALSE;
    31ac:	f003 03fb 	and.w	r3, r3, #251	; 0xfb
    31b0:	f36f 0341 	bfc	r3, #1, #1
    31b4:	7023      	strb	r3, [r4, #0]
    31b6:	e003      	b.n	31c0 <modbus_Process+0x50>
	// se não estamos esperando a resposta do modbus_SendCommand anterior vamos analisar o próximo comando a ser enviado
	if (!waitResponse) {
		tCommand cmdSend;
		u16 value = 0;
		int cmdConfig;
		if ( (control.setTempType) || (control.setTempStatics)) cmdConfig = pdTRUE; else cmdConfig = pdFALSE;
    31b8:	3600      	adds	r6, #0
    31ba:	bf18      	it	ne
    31bc:	2601      	movne	r6, #1
				#endif
			}
			control.setTempType = pdFALSE;
			control.setTempStatics = pdFALSE;
			cmdConfig = pdFALSE;
		} else thermometerAccess++;
    31be:	6029      	str	r1, [r5, #0]

		// verifica se foi emitido algum comando para configuração dos termômetros
		if ( (control.action == pdTRUE) && (triggerAction != control.action) && (cmdConfig) ) { // se é para fazer uma ação, faça
    31c0:	7823      	ldrb	r3, [r4, #0]
    31c2:	07da      	lsls	r2, r3, #31
    31c4:	d50d      	bpl.n	31e2 <modbus_Process+0x72>
    31c6:	4a44      	ldr	r2, [pc, #272]	; (32d8 <modbus_Process+0x168>)
    31c8:	f003 0301 	and.w	r3, r3, #1
    31cc:	6811      	ldr	r1, [r2, #0]
    31ce:	428b      	cmp	r3, r1
    31d0:	d007      	beq.n	31e2 <modbus_Process+0x72>
    31d2:	b136      	cbz	r6, 31e2 <modbus_Process+0x72>
			thermometerAccess = 1; // aponta para o primeiro termômetro
    31d4:	2101      	movs	r1, #1
    31d6:	6029      	str	r1, [r5, #0]
			triggerAction = control.action;
			#if (LOG_APP == pdON)
			plognp("Init config"CMD_TERMINATOR);
    31d8:	2002      	movs	r0, #2
    31da:	4941      	ldr	r1, [pc, #260]	; (32e0 <modbus_Process+0x170>)
		} else thermometerAccess++;

		// verifica se foi emitido algum comando para configuração dos termômetros
		if ( (control.action == pdTRUE) && (triggerAction != control.action) && (cmdConfig) ) { // se é para fazer uma ação, faça
			thermometerAccess = 1; // aponta para o primeiro termômetro
			triggerAction = control.action;
    31dc:	6013      	str	r3, [r2, #0]
			#if (LOG_APP == pdON)
			plognp("Init config"CMD_TERMINATOR);
    31de:	f000 fe37 	bl	3e50 <rprintf>
			#endif
		}

		if (control.setTempType) {
    31e2:	7823      	ldrb	r3, [r4, #0]
    31e4:	f003 0104 	and.w	r1, r3, #4
    31e8:	f001 02ff 	and.w	r2, r1, #255	; 0xff
    31ec:	b119      	cbz	r1, 31f6 <modbus_Process+0x86>
			cmdSend = cmdSET_TEMPERATURE_TYPE;
			value = control.tempType;
    31ee:	4b38      	ldr	r3, [pc, #224]	; (32d0 <modbus_Process+0x160>)
			plognp("Init config"CMD_TERMINATOR);
			#endif
		}

		if (control.setTempType) {
			cmdSend = cmdSET_TEMPERATURE_TYPE;
    31f0:	2103      	movs	r1, #3
			value = control.tempType;
    31f2:	889a      	ldrh	r2, [r3, #4]
    31f4:	e004      	b.n	3200 <modbus_Process+0x90>
	modbus_MasterProcess();

	// se não estamos esperando a resposta do modbus_SendCommand anterior vamos analisar o próximo comando a ser enviado
	if (!waitResponse) {
		tCommand cmdSend;
		u16 value = 0;
    31f6:	f013 0f02 	tst.w	r3, #2
    31fa:	bf14      	ite	ne
    31fc:	2104      	movne	r1, #4
    31fe:	2102      	moveq	r1, #2
			value = control.tempType;
		} else if (control.setTempStatics)
				cmdSend = cmdRST_TEMPERATURE_STATISTIC;
		else	cmdSend = cmdGET_TEMPERATURE;

		modbus_SendCommand(thermometerAccess, cmdSend, value);
    3200:	6828      	ldr	r0, [r5, #0]
    3202:	f7ff ff85 	bl	3110 <modbus_SendCommand>

		#if (LOG_APP == pdON)
		if ( cmdConfig ) plognp("Send Command to thermometer %d"CMD_TERMINATOR, thermometerAccess);
    3206:	2e00      	cmp	r6, #0
    3208:	d05e      	beq.n	32c8 <modbus_Process+0x158>
		control.thermometer[thermometerAccess-1].sts =  regs[0] & 0x1f;
		control.thermometer[thermometerAccess-1].value = regs[1];
		control.thermometer[thermometerAccess-1].valueMin = regs[2];
		control.thermometer[thermometerAccess-1].valueMax = regs[3];
	}
}
    320a:	e8bd 4070 	ldmia.w	sp!, {r4, r5, r6, lr}
		else	cmdSend = cmdGET_TEMPERATURE;

		modbus_SendCommand(thermometerAccess, cmdSend, value);

		#if (LOG_APP == pdON)
		if ( cmdConfig ) plognp("Send Command to thermometer %d"CMD_TERMINATOR, thermometerAccess);
    320e:	4b31      	ldr	r3, [pc, #196]	; (32d4 <modbus_Process+0x164>)
    3210:	4934      	ldr	r1, [pc, #208]	; (32e4 <modbus_Process+0x174>)
    3212:	681a      	ldr	r2, [r3, #0]
    3214:	2002      	movs	r0, #2
    3216:	f000 be1b 	b.w	3e50 <rprintf>
		#endif

		return;
	}

	int ret = modbus_MasterReadStatus();
    321a:	f000 f8d3 	bl	33c4 <modbus_MasterReadStatus>
	//  ERROR: Notificar um erro, e tomar o procedimento cabível
	//  OK para escrita: Fazer nada, pois os valores dos registradores foram salvos no escravo com sucesso
	//	OK para Leitura: Capturar os valores dos registradores lidos do escravo

	// se ainda está ocupado não faz nada
	if (ret == errMODBUS_BUSY) return;
    321e:	f110 0f86 	cmn.w	r0, #134	; 0x86
    3222:	d051      	beq.n	32c8 <modbus_Process+0x158>
	waitResponse = pdFALSE;
    3224:	2100      	movs	r1, #0
    3226:	4b30      	ldr	r3, [pc, #192]	; (32e8 <modbus_Process+0x178>)
	// se for algum erro
	if (ret < 0) {
    3228:	4288      	cmp	r0, r1
	//  OK para escrita: Fazer nada, pois os valores dos registradores foram salvos no escravo com sucesso
	//	OK para Leitura: Capturar os valores dos registradores lidos do escravo

	// se ainda está ocupado não faz nada
	if (ret == errMODBUS_BUSY) return;
	waitResponse = pdFALSE;
    322a:	6021      	str	r1, [r4, #0]
	// se for algum erro
	if (ret < 0) {
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("modbus err[%d] wait response "CMD_TERMINATOR, ret);
		#endif
		if (cmd == cmdGET_TEMPERATURE) {
    322c:	781b      	ldrb	r3, [r3, #0]

	// se ainda está ocupado não faz nada
	if (ret == errMODBUS_BUSY) return;
	waitResponse = pdFALSE;
	// se for algum erro
	if (ret < 0) {
    322e:	da14      	bge.n	325a <modbus_Process+0xea>
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("modbus err[%d] wait response "CMD_TERMINATOR, ret);
		#endif
		if (cmd == cmdGET_TEMPERATURE) {
    3230:	2b02      	cmp	r3, #2
    3232:	d149      	bne.n	32c8 <modbus_Process+0x158>
    3234:	4b27      	ldr	r3, [pc, #156]	; (32d4 <modbus_Process+0x164>)
			if (ret == errMODBUS_EXCEPTION)
    3236:	3082      	adds	r0, #130	; 0x82
    3238:	4d25      	ldr	r5, [pc, #148]	; (32d0 <modbus_Process+0x160>)
		 		control.thermometer[thermometerAccess-1].stsCom = modbus_MasterReadException();
    323a:	681a      	ldr	r2, [r3, #0]
	if (ret < 0) {
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("modbus err[%d] wait response "CMD_TERMINATOR, ret);
		#endif
		if (cmd == cmdGET_TEMPERATURE) {
			if (ret == errMODBUS_EXCEPTION)
    323c:	d107      	bne.n	324e <modbus_Process+0xde>
		 		control.thermometer[thermometerAccess-1].stsCom = modbus_MasterReadException();
    323e:	1e54      	subs	r4, r2, #1
    3240:	f000 f8c6 	bl	33d0 <modbus_MasterReadException>
    3244:	231c      	movs	r3, #28
    3246:	fb03 5404 	mla	r4, r3, r4, r5
    324a:	6220      	str	r0, [r4, #32]
    324c:	bd70      	pop	{r4, r5, r6, pc}
					// modbusILLEGAL_FUNCTION: O termômetro recebeu uma função que não foi implementada ou não foi habilitada.
					// modbusILLEGAL_DATA_ADDRESS: O termômetro precisou acessar um endereço inexistente.
					// modbusILLEGAL_DATA_VALUE: O valor contido no campo de dado não é permitido pelo termômetro. Isto indica uma falta de informações na estrutura do campo de dados.
					// modbusSLAVE_DEVICE_FAILURE: Um irrecuperável erro ocorreu enquanto o termômetro estava tentando executar a ação solicitada.
			else control.thermometer[thermometerAccess-1].stsCom = 0; // sinaliza que não há comunicação com o termômetro
    324e:	3a01      	subs	r2, #1
    3250:	231c      	movs	r3, #28
    3252:	fb03 5302 	mla	r3, r3, r2, r5
    3256:	6219      	str	r1, [r3, #32]
    3258:	bd70      	pop	{r4, r5, r6, pc}
	#if (LOG_MODBUS_MASTER == pdON)
   	plognp("Response thermometer %d"CMD_TERMINATOR, thermometerAccess);
   	#endif

    // Comando para ler os registradores: modelo e versão firmware
    if (cmd == cmdGET_INFO) {
    325a:	2b01      	cmp	r3, #1
    325c:	d11e      	bne.n	329c <modbus_Process+0x12c>
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("model %c%c%c%c"CMD_TERMINATOR, (regs[0] & 0xff), (regs[0] >> 8), (regs[1] & 0xff), (regs[1] >> 8));
    	plognp("firmware %c.%c"CMD_TERMINATOR, (regs[2] & 0xff), (regs[2] >> 8));
    	#endif
    	control.thermometer[thermometerAccess-1].model[0] = (regs[0] & 0xff);
    325e:	4b1d      	ldr	r3, [pc, #116]	; (32d4 <modbus_Process+0x164>)
    3260:	251c      	movs	r5, #28
    3262:	681b      	ldr	r3, [r3, #0]
    3264:	4c21      	ldr	r4, [pc, #132]	; (32ec <modbus_Process+0x17c>)
    3266:	1e5a      	subs	r2, r3, #1
    3268:	4b19      	ldr	r3, [pc, #100]	; (32d0 <modbus_Process+0x160>)
    326a:	8820      	ldrh	r0, [r4, #0]
    326c:	fb05 3302 	mla	r3, r5, r2, r3
    	control.thermometer[thermometerAccess-1].model[1] = (regs[0] >> 8);
    	control.thermometer[thermometerAccess-1].model[2] = (regs[1] & 0xff);
    3270:	8862      	ldrh	r2, [r4, #2]
    if (cmd == cmdGET_INFO) {
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("model %c%c%c%c"CMD_TERMINATOR, (regs[0] & 0xff), (regs[0] >> 8), (regs[1] & 0xff), (regs[1] >> 8));
    	plognp("firmware %c.%c"CMD_TERMINATOR, (regs[2] & 0xff), (regs[2] >> 8));
    	#endif
    	control.thermometer[thermometerAccess-1].model[0] = (regs[0] & 0xff);
    3272:	f883 0034 	strb.w	r0, [r3, #52]	; 0x34
    	control.thermometer[thermometerAccess-1].model[1] = (regs[0] >> 8);
    	control.thermometer[thermometerAccess-1].model[2] = (regs[1] & 0xff);
    3276:	f883 2036 	strb.w	r2, [r3, #54]	; 0x36
    	control.thermometer[thermometerAccess-1].model[3] = (regs[1] >> 8);
    327a:	0a12      	lsrs	r2, r2, #8
    327c:	f883 2037 	strb.w	r2, [r3, #55]	; 0x37
    	control.thermometer[thermometerAccess-1].model[4] = 0;
    	control.thermometer[thermometerAccess-1].firmware[0] = (regs[2] & 0xff);
    3280:	88a2      	ldrh	r2, [r4, #4]
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("model %c%c%c%c"CMD_TERMINATOR, (regs[0] & 0xff), (regs[0] >> 8), (regs[1] & 0xff), (regs[1] >> 8));
    	plognp("firmware %c.%c"CMD_TERMINATOR, (regs[2] & 0xff), (regs[2] >> 8));
    	#endif
    	control.thermometer[thermometerAccess-1].model[0] = (regs[0] & 0xff);
    	control.thermometer[thermometerAccess-1].model[1] = (regs[0] >> 8);
    3282:	0a00      	lsrs	r0, r0, #8
    	control.thermometer[thermometerAccess-1].model[2] = (regs[1] & 0xff);
    	control.thermometer[thermometerAccess-1].model[3] = (regs[1] >> 8);
    	control.thermometer[thermometerAccess-1].model[4] = 0;
    	control.thermometer[thermometerAccess-1].firmware[0] = (regs[2] & 0xff);
    3284:	f883 2039 	strb.w	r2, [r3, #57]	; 0x39
    	control.thermometer[thermometerAccess-1].firmware[1] = (regs[2] >> 8);
    3288:	0a12      	lsrs	r2, r2, #8
    	#if (LOG_MODBUS_MASTER == pdON)
    	plognp("model %c%c%c%c"CMD_TERMINATOR, (regs[0] & 0xff), (regs[0] >> 8), (regs[1] & 0xff), (regs[1] >> 8));
    	plognp("firmware %c.%c"CMD_TERMINATOR, (regs[2] & 0xff), (regs[2] >> 8));
    	#endif
    	control.thermometer[thermometerAccess-1].model[0] = (regs[0] & 0xff);
    	control.thermometer[thermometerAccess-1].model[1] = (regs[0] >> 8);
    328a:	f883 0035 	strb.w	r0, [r3, #53]	; 0x35
    	control.thermometer[thermometerAccess-1].model[2] = (regs[1] & 0xff);
    	control.thermometer[thermometerAccess-1].model[3] = (regs[1] >> 8);
    	control.thermometer[thermometerAccess-1].model[4] = 0;
    328e:	f883 1038 	strb.w	r1, [r3, #56]	; 0x38
    	control.thermometer[thermometerAccess-1].firmware[0] = (regs[2] & 0xff);
    	control.thermometer[thermometerAccess-1].firmware[1] = (regs[2] >> 8);
    3292:	f883 203a 	strb.w	r2, [r3, #58]	; 0x3a
    	control.thermometer[thermometerAccess-1].firmware[2] = 0;
    3296:	f883 103b 	strb.w	r1, [r3, #59]	; 0x3b
    329a:	bd70      	pop	{r4, r5, r6, pc}

	// Comando para ler o termômetro
    } else if (cmd == cmdGET_TEMPERATURE) {
    329c:	2b02      	cmp	r3, #2
    329e:	d113      	bne.n	32c8 <modbus_Process+0x158>
		control.thermometer[thermometerAccess-1].stsCom = 5; // sinaliza que a conexão fou feita com sucesso
    32a0:	4b0c      	ldr	r3, [pc, #48]	; (32d4 <modbus_Process+0x164>)
    32a2:	211c      	movs	r1, #28
    32a4:	681b      	ldr	r3, [r3, #0]
    32a6:	1e5a      	subs	r2, r3, #1
    32a8:	4b09      	ldr	r3, [pc, #36]	; (32d0 <modbus_Process+0x160>)
    32aa:	fb01 3302 	mla	r3, r1, r2, r3
    32ae:	2205      	movs	r2, #5
    32b0:	621a      	str	r2, [r3, #32]
		control.thermometer[thermometerAccess-1].sts =  regs[0] & 0x1f;
    32b2:	4a0e      	ldr	r2, [pc, #56]	; (32ec <modbus_Process+0x17c>)
    32b4:	8811      	ldrh	r1, [r2, #0]
    32b6:	f001 011f 	and.w	r1, r1, #31
    32ba:	8499      	strh	r1, [r3, #36]	; 0x24
		control.thermometer[thermometerAccess-1].value = regs[1];
    32bc:	8851      	ldrh	r1, [r2, #2]
    32be:	6299      	str	r1, [r3, #40]	; 0x28
		control.thermometer[thermometerAccess-1].valueMin = regs[2];
    32c0:	8891      	ldrh	r1, [r2, #4]
		control.thermometer[thermometerAccess-1].valueMax = regs[3];
    32c2:	88d2      	ldrh	r2, [r2, #6]
	// Comando para ler o termômetro
    } else if (cmd == cmdGET_TEMPERATURE) {
		control.thermometer[thermometerAccess-1].stsCom = 5; // sinaliza que a conexão fou feita com sucesso
		control.thermometer[thermometerAccess-1].sts =  regs[0] & 0x1f;
		control.thermometer[thermometerAccess-1].value = regs[1];
		control.thermometer[thermometerAccess-1].valueMin = regs[2];
    32c4:	62d9      	str	r1, [r3, #44]	; 0x2c
		control.thermometer[thermometerAccess-1].valueMax = regs[3];
    32c6:	631a      	str	r2, [r3, #48]	; 0x30
    32c8:	bd70      	pop	{r4, r5, r6, pc}
    32ca:	bf00      	nop
    32cc:	10000a60 	.word	0x10000a60
    32d0:	100005ac 	.word	0x100005ac
    32d4:	10000004 	.word	0x10000004
    32d8:	10000a64 	.word	0x10000a64
    32dc:	000053e3 	.word	0x000053e3
    32e0:	000053f2 	.word	0x000053f2
    32e4:	000053ff 	.word	0x000053ff
    32e8:	10000a5c 	.word	0x10000a5c
    32ec:	10000a68 	.word	0x10000a68

Disassembly of section .text.crc16_Right:

000032f0 <crc16_Right>:
//16bits CRC right shifted
//data = buffer de bytes a serem calculados
//length = quantidade de bytes
//poly = polinomio original
//init = valor inicial do crc
static u16 crc16_Right(void* data, int length, u16 poly, u16 init) {
    32f0:	b570      	push	{r4, r5, r6, lr}
    32f2:	2510      	movs	r5, #16
static u16 crc16_Right(void* data, int length, u16 poly, u16 init);
static u16 crc16_Left(void* data, int length, u16 poly, u16 init);

//cria espelho do polinomio
static u16 crc16_Poly (u16 poly) {
    u16 i, r = 0;
    32f4:	2400      	movs	r4, #0
    for (i=0;i<16;i++) {
        r = r << 1;
        r = r | (poly&1);
    32f6:	f002 0601 	and.w	r6, r2, #1
    32fa:	3d01      	subs	r5, #1
    32fc:	ea46 0444 	orr.w	r4, r6, r4, lsl #1
    3300:	b2ad      	uxth	r5, r5
    3302:	b2a4      	uxth	r4, r4
        poly = poly >> 1;
    3304:	0852      	lsrs	r2, r2, #1
static u16 crc16_Left(void* data, int length, u16 poly, u16 init);

//cria espelho do polinomio
static u16 crc16_Poly (u16 poly) {
    u16 i, r = 0;
    for (i=0;i<16;i++) {
    3306:	2d00      	cmp	r5, #0
    3308:	d1f5      	bne.n	32f6 <crc16_Right+0x6>
    330a:	4401      	add	r1, r0
//init = valor inicial do crc
static u16 crc16_Right(void* data, int length, u16 poly, u16 init) {
	u16 i, crc = init;
	u8 * p = data;
	poly = crc16_Poly(poly);
	while (length--) {
    330c:	4288      	cmp	r0, r1
    330e:	d010      	beq.n	3332 <crc16_Right+0x42>
		crc = crc ^ (*p++);
    3310:	f810 2b01 	ldrb.w	r2, [r0], #1
    3314:	4053      	eors	r3, r2
    3316:	2208      	movs	r2, #8
		for (i = 0; i < 8; i++)
			crc = (crc & 0x0001) ? (crc >> 1) ^ poly : (crc >> 1);
    3318:	f013 0f01 	tst.w	r3, #1
    331c:	f102 32ff 	add.w	r2, r2, #4294967295
    3320:	ea4f 0353 	mov.w	r3, r3, lsr #1
    3324:	b29b      	uxth	r3, r3
    3326:	b292      	uxth	r2, r2
    3328:	bf18      	it	ne
    332a:	4063      	eorne	r3, r4
	u16 i, crc = init;
	u8 * p = data;
	poly = crc16_Poly(poly);
	while (length--) {
		crc = crc ^ (*p++);
		for (i = 0; i < 8; i++)
    332c:	2a00      	cmp	r2, #0
    332e:	d1f3      	bne.n	3318 <crc16_Right+0x28>
    3330:	e7ec      	b.n	330c <crc16_Right+0x1c>
			crc = (crc & 0x0001) ? (crc >> 1) ^ poly : (crc >> 1);
	}
	return crc;
}
    3332:	4618      	mov	r0, r3
    3334:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.crc16_MODBUS:

00003336 <crc16_MODBUS>:
	return crc16_Right(data, length, 0x8005, 0x0000);
}

//poly = x16 + x15 + x2 + x0 = 0x8005
u16 crc16_MODBUS(void* data, int length) {
	return crc16_Right( data, length, 0x8005, 0xFFFF );
    3336:	f64f 73ff 	movw	r3, #65535	; 0xffff
    333a:	f248 0205 	movw	r2, #32773	; 0x8005
    333e:	f7ff bfd7 	b.w	32f0 <crc16_Right>

Disassembly of section .text.ValidatePacket:

00003344 <ValidatePacket>:
//				errMODBUS_CMD: O comando (função) do pacote de recebimento do escravo não bate com o comando enviado a ele
//				errMODBUS_EXCEPTION: Sinaliza que o escravo enviou uma exceção, consultar status
// -------------------------------------------------------------------------------------------------------------------
static int ValidatePacket(void) {
    // checar se o ID do escravo é o mesmo enviado
    if (modbus.querie[0] != modbus.slaveID)
    3344:	4b0e      	ldr	r3, [pc, #56]	; (3380 <ValidatePacket+0x3c>)
    3346:	7c19      	ldrb	r1, [r3, #16]
    3348:	f8d3 2110 	ldr.w	r2, [r3, #272]	; 0x110
    334c:	4291      	cmp	r1, r2
    334e:	d10e      	bne.n	336e <ValidatePacket+0x2a>
		return errMODBUS_ID;

	 // checar se a função é a mesma enviada
    if ((modbus.querie[1] & 0x7f) != modbus.cmd)
    3350:	7c5a      	ldrb	r2, [r3, #17]
    3352:	f8d3 1114 	ldr.w	r1, [r3, #276]	; 0x114
    3356:	f002 007f 	and.w	r0, r2, #127	; 0x7f
    335a:	4288      	cmp	r0, r1
    335c:	d10a      	bne.n	3374 <ValidatePacket+0x30>
        return errMODBUS_CMD;

	// checa se o escravo mandou algum erro de exceção
	if ((modbus.querie[1] & 0x80) > 0) {
    335e:	0612      	lsls	r2, r2, #24
    3360:	d50b      	bpl.n	337a <ValidatePacket+0x36>
        modbus.exception = modbus.querie[2];
    3362:	7c9a      	ldrb	r2, [r3, #18]
        return errMODBUS_EXCEPTION;
    3364:	f06f 0081 	mvn.w	r0, #129	; 0x81
    if ((modbus.querie[1] & 0x7f) != modbus.cmd)
        return errMODBUS_CMD;

	// checa se o escravo mandou algum erro de exceção
	if ((modbus.querie[1] & 0x80) > 0) {
        modbus.exception = modbus.querie[2];
    3368:	f8c3 2138 	str.w	r2, [r3, #312]	; 0x138
        return errMODBUS_EXCEPTION;
    336c:	4770      	bx	lr
//				errMODBUS_EXCEPTION: Sinaliza que o escravo enviou uma exceção, consultar status
// -------------------------------------------------------------------------------------------------------------------
static int ValidatePacket(void) {
    // checar se o ID do escravo é o mesmo enviado
    if (modbus.querie[0] != modbus.slaveID)
		return errMODBUS_ID;
    336e:	f06f 007e 	mvn.w	r0, #126	; 0x7e
    3372:	4770      	bx	lr

	 // checar se a função é a mesma enviada
    if ((modbus.querie[1] & 0x7f) != modbus.cmd)
        return errMODBUS_CMD;
    3374:	f06f 0080 	mvn.w	r0, #128	; 0x80
    3378:	4770      	bx	lr
	if ((modbus.querie[1] & 0x80) > 0) {
        modbus.exception = modbus.querie[2];
        return errMODBUS_EXCEPTION;
	}

	return pdPASS;
    337a:	2001      	movs	r0, #1
}
    337c:	4770      	bx	lr
    337e:	bf00      	nop
    3380:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_MasterInit:

00003384 <modbus_MasterInit>:
void modbus_MasterInit(
	int(*puts_func)(u8* buffer, u16 count),
	int(*getc_func)(u8* ch),
	void(*flushRX_func)(void)
) {
	modbus.ps = puts_func;
    3384:	4b0b      	ldr	r3, [pc, #44]	; (33b4 <modbus_MasterInit+0x30>)
	modbus.gc = getc_func;
	modbus.flushRX = flushRX_func;
    3386:	e883 0007 	stmia.w	r3, {r0, r1, r2}

	modbus.slaveID = 0;
    338a:	2200      	movs	r2, #0
	modbus.sts = 0;
	modbus.regs = NULL;
	modbus.len = 0;
	modbus.waitResponse = pdFALSE;
	modbus.exception = modbusNO_ERROR;
	modbus.tout = 0;
    338c:	f8c3 211c 	str.w	r2, [r3, #284]	; 0x11c
) {
	modbus.ps = puts_func;
	modbus.gc = getc_func;
	modbus.flushRX = flushRX_func;

	modbus.slaveID = 0;
    3390:	f8c3 2110 	str.w	r2, [r3, #272]	; 0x110
	modbus.cmd = 0;
    3394:	f8c3 2114 	str.w	r2, [r3, #276]	; 0x114
	modbus.sts = 0;
    3398:	f8c3 2134 	str.w	r2, [r3, #308]	; 0x134
	modbus.regs = NULL;
    339c:	f8c3 2124 	str.w	r2, [r3, #292]	; 0x124
	modbus.len = 0;
    33a0:	f8c3 2128 	str.w	r2, [r3, #296]	; 0x128
	modbus.waitResponse = pdFALSE;
    33a4:	f8c3 2118 	str.w	r2, [r3, #280]	; 0x118
	modbus.exception = modbusNO_ERROR;
    33a8:	f8c3 2138 	str.w	r2, [r3, #312]	; 0x138
	modbus.tout = 0;
	modbus.timeDataIn = modbusTIME_DATE_IN;
    33ac:	22c8      	movs	r2, #200	; 0xc8
    33ae:	f8c3 2120 	str.w	r2, [r3, #288]	; 0x120
    33b2:	4770      	bx	lr
    33b4:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_MasterTimeout:

000033b8 <modbus_MasterTimeout>:
// Parametro:	timeout:  Tempo de espera pela resposta do escravo após envio de um comando
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
// Exemplo para readregs_func:	modbus_MasterTimeout(3000); timeout = 3000 (3 segundos)
void modbus_MasterTimeout(uint timeout) {
	modbus.timeout = timeout;
    33b8:	4b01      	ldr	r3, [pc, #4]	; (33c0 <modbus_MasterTimeout+0x8>)
    33ba:	60d8      	str	r0, [r3, #12]
    33bc:	4770      	bx	lr
    33be:	bf00      	nop
    33c0:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_MasterReadStatus:

000033c4 <modbus_MasterReadStatus>:
//				errMODBUS_EXCEPTION: Sinaliza que o escravo enviou uma exceção, consultar status
//				errMODBUS_LEN
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadStatus(void) {
	return modbus.sts;
}
    33c4:	4b01      	ldr	r3, [pc, #4]	; (33cc <modbus_MasterReadStatus+0x8>)
    33c6:	f8d3 0134 	ldr.w	r0, [r3, #308]	; 0x134
    33ca:	4770      	bx	lr
    33cc:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_MasterReadException:

000033d0 <modbus_MasterReadException>:
// 				modbusILLEGAL_DATA_VALUE: O valor contido no campo de dado não é permitido pelo escravo. Isto indica uma falta de informações na estrutura do campo de dados.
// 				modbusSLAVE_DEVICE_FAILURE: Um irrecuperável erro ocorreu enquanto o escravo estava tentando executar a ação solicitada.
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadException(void) {
	return modbus.exception;
}
    33d0:	4b01      	ldr	r3, [pc, #4]	; (33d8 <modbus_MasterReadException+0x8>)
    33d2:	f8d3 0138 	ldr.w	r0, [r3, #312]	; 0x138
    33d6:	4770      	bx	lr
    33d8:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_MasterReadRegisters:

000033dc <modbus_MasterReadRegisters>:
//					pdPASS: Avisar ao sistema que a leitura dos registradores foi feita com sucesso e é para capturar seus valores
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadRegisters(int addrSlave, int addrInit, int len, u16* regs) {
    33dc:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
	if (modbus.waitResponse) return pdFAIL;
    33de:	4c1d      	ldr	r4, [pc, #116]	; (3454 <modbus_MasterReadRegisters+0x78>)
//					pdPASS: Avisar ao sistema que a leitura dos registradores foi feita com sucesso e é para capturar seus valores
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadRegisters(int addrSlave, int addrInit, int len, u16* regs) {
    33e0:	460f      	mov	r7, r1
	if (modbus.waitResponse) return pdFAIL;
    33e2:	f8d4 5118 	ldr.w	r5, [r4, #280]	; 0x118
//					pdPASS: Avisar ao sistema que a leitura dos registradores foi feita com sucesso e é para capturar seus valores
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadRegisters(int addrSlave, int addrInit, int len, u16* regs) {
    33e6:	4616      	mov	r6, r2
	if (modbus.waitResponse) return pdFAIL;
    33e8:	bb8d      	cbnz	r5, 344e <modbus_MasterReadRegisters+0x72>

	modbus.slaveID = addrSlave;
	modbus.cmd = 3;
    33ea:	2203      	movs	r2, #3
	modbus.len = len;
	modbus.regs = regs;
    33ec:	f8c4 3124 	str.w	r3, [r4, #292]	; 0x124
	modbus.sts = errMODBUS_BUSY;
    33f0:	f06f 0385 	mvn.w	r3, #133	; 0x85
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadRegisters(int addrSlave, int addrInit, int len, u16* regs) {
	if (modbus.waitResponse) return pdFAIL;

	modbus.slaveID = addrSlave;
	modbus.cmd = 3;
    33f4:	f8c4 2114 	str.w	r2, [r4, #276]	; 0x114
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadRegisters(int addrSlave, int addrInit, int len, u16* regs) {
	if (modbus.waitResponse) return pdFAIL;

	modbus.slaveID = addrSlave;
    33f8:	f8c4 0110 	str.w	r0, [r4, #272]	; 0x110
	modbus.cmd = 3;
	modbus.len = len;
	modbus.regs = regs;
	modbus.sts = errMODBUS_BUSY;
    33fc:	f8c4 3134 	str.w	r3, [r4, #308]	; 0x134
int modbus_MasterReadRegisters(int addrSlave, int addrInit, int len, u16* regs) {
	if (modbus.waitResponse) return pdFAIL;

	modbus.slaveID = addrSlave;
	modbus.cmd = 3;
	modbus.len = len;
    3400:	f8c4 6128 	str.w	r6, [r4, #296]	; 0x128
	modbus.regs = regs;
	modbus.sts = errMODBUS_BUSY;

	modbus.flushRX(); // limpa os byffers RX da serial
    3404:	68a3      	ldr	r3, [r4, #8]
    3406:	4798      	blx	r3

   	// preparar a query
	modbus.querie[0] = modbus.slaveID;
    3408:	f8d4 3110 	ldr.w	r3, [r4, #272]	; 0x110
    modbus.querie[1] = modbus.cmd;
    modbus.querie[2] = (addrInit >> 8) & 0xff;
    modbus.querie[3] = addrInit & 0xff;
    modbus.querie[4] = (len >> 8) & 0xff;
    modbus.querie[5] = len & 0xff;
    u16 crc = crc16_MODBUS(modbus.querie, 6);
    340c:	2106      	movs	r1, #6
	modbus.sts = errMODBUS_BUSY;

	modbus.flushRX(); // limpa os byffers RX da serial

   	// preparar a query
	modbus.querie[0] = modbus.slaveID;
    340e:	7423      	strb	r3, [r4, #16]
    modbus.querie[1] = modbus.cmd;
    3410:	f8d4 3114 	ldr.w	r3, [r4, #276]	; 0x114
    modbus.querie[2] = (addrInit >> 8) & 0xff;
    modbus.querie[3] = addrInit & 0xff;
    modbus.querie[4] = (len >> 8) & 0xff;
    modbus.querie[5] = len & 0xff;
    u16 crc = crc16_MODBUS(modbus.querie, 6);
    3414:	f104 0010 	add.w	r0, r4, #16

	modbus.flushRX(); // limpa os byffers RX da serial

   	// preparar a query
	modbus.querie[0] = modbus.slaveID;
    modbus.querie[1] = modbus.cmd;
    3418:	7463      	strb	r3, [r4, #17]
    modbus.querie[2] = (addrInit >> 8) & 0xff;
    341a:	123b      	asrs	r3, r7, #8
    341c:	74a3      	strb	r3, [r4, #18]
    modbus.querie[3] = addrInit & 0xff;
    modbus.querie[4] = (len >> 8) & 0xff;
    341e:	1233      	asrs	r3, r6, #8
    3420:	7523      	strb	r3, [r4, #20]

   	// preparar a query
	modbus.querie[0] = modbus.slaveID;
    modbus.querie[1] = modbus.cmd;
    modbus.querie[2] = (addrInit >> 8) & 0xff;
    modbus.querie[3] = addrInit & 0xff;
    3422:	74e7      	strb	r7, [r4, #19]
    modbus.querie[4] = (len >> 8) & 0xff;
    modbus.querie[5] = len & 0xff;
    3424:	7566      	strb	r6, [r4, #21]
    u16 crc = crc16_MODBUS(modbus.querie, 6);
    3426:	f7ff ff86 	bl	3336 <crc16_MODBUS>
    modbus.querie[6] = crc & 0xff;
    342a:	75a0      	strb	r0, [r4, #22]
    modbus.querie[7] = (crc >> 8) & 0xff;
    342c:	0a00      	lsrs	r0, r0, #8
    342e:	75e0      	strb	r0, [r4, #23]

    // enviar a query para o escravo
    if (modbus.ps(modbus.querie, 8) < 0) {
    3430:	4620      	mov	r0, r4
    3432:	2108      	movs	r1, #8
    3434:	f850 3b10 	ldr.w	r3, [r0], #16
    3438:	4798      	blx	r3
    343a:	2800      	cmp	r0, #0
        modbus.sts = errMODBUS_TX;
    343c:	bfb5      	itete	lt
    343e:	f06f 037a 	mvnlt.w	r3, #122	; 0x7a
        return pdFAIL;
	}

	// sinalisa que vamos esperar a resposta do escravo
	modbus.waitResponse = pdTRUE;
    3442:	2501      	movge	r5, #1
    modbus.querie[6] = crc & 0xff;
    modbus.querie[7] = (crc >> 8) & 0xff;

    // enviar a query para o escravo
    if (modbus.ps(modbus.querie, 8) < 0) {
        modbus.sts = errMODBUS_TX;
    3444:	f8c4 3134 	strlt.w	r3, [r4, #308]	; 0x134
        return pdFAIL;
	}

	// sinalisa que vamos esperar a resposta do escravo
	modbus.waitResponse = pdTRUE;
    3448:	f8c4 5118 	strge.w	r5, [r4, #280]	; 0x118
	modbus_printf("modbusM: TX RR: ");
	int x; for (x=0;x<8;x++) modbus_printf("0x%x ", modbus.querie[x]);
	modbus_printf(CMD_TERMINATOR);
	#endif

    return pdPASS;
    344c:	e000      	b.n	3450 <modbus_MasterReadRegisters+0x74>
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterReadRegisters(int addrSlave, int addrInit, int len, u16* regs) {
	if (modbus.waitResponse) return pdFAIL;
    344e:	2500      	movs	r5, #0
	int x; for (x=0;x<8;x++) modbus_printf("0x%x ", modbus.querie[x]);
	modbus_printf(CMD_TERMINATOR);
	#endif

    return pdPASS;
}
    3450:	4628      	mov	r0, r5
    3452:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    3454:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_MasterWriteRegister:

00003458 <modbus_MasterWriteRegister>:
//					pdPASS: Avisar ao sistema que a escrita no registrador foi feita com sucesso
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis.
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterWriteRegister(int addrSlave, int addr, u16 value) {
    3458:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
	if (modbus.waitResponse) return pdFAIL;
    345c:	4c1e      	ldr	r4, [pc, #120]	; (34d8 <modbus_MasterWriteRegister+0x80>)
//					pdPASS: Avisar ao sistema que a escrita no registrador foi feita com sucesso
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis.
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterWriteRegister(int addrSlave, int addr, u16 value) {
    345e:	460f      	mov	r7, r1
	if (modbus.waitResponse) return pdFAIL;
    3460:	f8d4 5118 	ldr.w	r5, [r4, #280]	; 0x118
//					pdPASS: Avisar ao sistema que a escrita no registrador foi feita com sucesso
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis.
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterWriteRegister(int addrSlave, int addr, u16 value) {
    3464:	4616      	mov	r6, r2
	if (modbus.waitResponse) return pdFAIL;
    3466:	bb95      	cbnz	r5, 34ce <modbus_MasterWriteRegister+0x76>

	modbus.slaveID = addrSlave;
	modbus.cmd = 6;
    3468:	f04f 0806 	mov.w	r8, #6
	modbus.addr = addr;
	modbus.value = value;
	modbus.sts = errMODBUS_BUSY;
    346c:	f06f 0385 	mvn.w	r3, #133	; 0x85
	if (modbus.waitResponse) return pdFAIL;

	modbus.slaveID = addrSlave;
	modbus.cmd = 6;
	modbus.addr = addr;
	modbus.value = value;
    3470:	f8a4 2130 	strh.w	r2, [r4, #304]	; 0x130
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterWriteRegister(int addrSlave, int addr, u16 value) {
	if (modbus.waitResponse) return pdFAIL;

	modbus.slaveID = addrSlave;
    3474:	f8c4 0110 	str.w	r0, [r4, #272]	; 0x110
	modbus.cmd = 6;
	modbus.addr = addr;
    3478:	f8c4 112c 	str.w	r1, [r4, #300]	; 0x12c
	modbus.value = value;
	modbus.sts = errMODBUS_BUSY;
    347c:	f8c4 3134 	str.w	r3, [r4, #308]	; 0x134
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterWriteRegister(int addrSlave, int addr, u16 value) {
	if (modbus.waitResponse) return pdFAIL;

	modbus.slaveID = addrSlave;
	modbus.cmd = 6;
    3480:	f8c4 8114 	str.w	r8, [r4, #276]	; 0x114
	modbus.addr = addr;
	modbus.value = value;
	modbus.sts = errMODBUS_BUSY;

	modbus.flushRX(); // limpa os byffers RX da serial
    3484:	68a3      	ldr	r3, [r4, #8]
    3486:	4798      	blx	r3

    // preparar a query
    modbus.querie[0] = modbus.slaveID;
    3488:	f8d4 3110 	ldr.w	r3, [r4, #272]	; 0x110
    modbus.querie[1] = modbus.cmd;
    modbus.querie[2] = (addr >> 8) & 0xff;
    modbus.querie[3] = addr & 0xff;
    modbus.querie[4] = (value >> 8) & 0xff;
    modbus.querie[5] = value & 0xff;
    u16 crc = crc16_MODBUS(modbus.querie, 6);
    348c:	4641      	mov	r1, r8
	modbus.sts = errMODBUS_BUSY;

	modbus.flushRX(); // limpa os byffers RX da serial

    // preparar a query
    modbus.querie[0] = modbus.slaveID;
    348e:	7423      	strb	r3, [r4, #16]
    modbus.querie[1] = modbus.cmd;
    3490:	f8d4 3114 	ldr.w	r3, [r4, #276]	; 0x114
    modbus.querie[2] = (addr >> 8) & 0xff;
    modbus.querie[3] = addr & 0xff;
    modbus.querie[4] = (value >> 8) & 0xff;
    modbus.querie[5] = value & 0xff;
    u16 crc = crc16_MODBUS(modbus.querie, 6);
    3494:	f104 0010 	add.w	r0, r4, #16

	modbus.flushRX(); // limpa os byffers RX da serial

    // preparar a query
    modbus.querie[0] = modbus.slaveID;
    modbus.querie[1] = modbus.cmd;
    3498:	7463      	strb	r3, [r4, #17]
    modbus.querie[2] = (addr >> 8) & 0xff;
    349a:	123b      	asrs	r3, r7, #8
    349c:	74a3      	strb	r3, [r4, #18]
    modbus.querie[3] = addr & 0xff;
    modbus.querie[4] = (value >> 8) & 0xff;
    349e:	0a33      	lsrs	r3, r6, #8
    34a0:	7523      	strb	r3, [r4, #20]

    // preparar a query
    modbus.querie[0] = modbus.slaveID;
    modbus.querie[1] = modbus.cmd;
    modbus.querie[2] = (addr >> 8) & 0xff;
    modbus.querie[3] = addr & 0xff;
    34a2:	74e7      	strb	r7, [r4, #19]
    modbus.querie[4] = (value >> 8) & 0xff;
    modbus.querie[5] = value & 0xff;
    34a4:	7566      	strb	r6, [r4, #21]
    u16 crc = crc16_MODBUS(modbus.querie, 6);
    34a6:	f7ff ff46 	bl	3336 <crc16_MODBUS>
    modbus.querie[6] = crc & 0xff;
    34aa:	75a0      	strb	r0, [r4, #22]
    modbus.querie[7] = (crc >> 8) & 0xff;
    34ac:	0a00      	lsrs	r0, r0, #8
    34ae:	75e0      	strb	r0, [r4, #23]

	// enviar a query para o escravo
    if (modbus.ps(modbus.querie, 8) < 0) {
    34b0:	4620      	mov	r0, r4
    34b2:	2108      	movs	r1, #8
    34b4:	f850 3b10 	ldr.w	r3, [r0], #16
    34b8:	4798      	blx	r3
    34ba:	2800      	cmp	r0, #0
        modbus.sts = errMODBUS_TX;
    34bc:	bfb5      	itete	lt
    34be:	f06f 037a 	mvnlt.w	r3, #122	; 0x7a
        return pdFAIL;
	}

	// sinalisa que vamos esperar a resposta do escravo
	modbus.waitResponse = pdTRUE;
    34c2:	2501      	movge	r5, #1
    modbus.querie[6] = crc & 0xff;
    modbus.querie[7] = (crc >> 8) & 0xff;

	// enviar a query para o escravo
    if (modbus.ps(modbus.querie, 8) < 0) {
        modbus.sts = errMODBUS_TX;
    34c4:	f8c4 3134 	strlt.w	r3, [r4, #308]	; 0x134
        return pdFAIL;
	}

	// sinalisa que vamos esperar a resposta do escravo
	modbus.waitResponse = pdTRUE;
    34c8:	f8c4 5118 	strge.w	r5, [r4, #280]	; 0x118
	modbus_printf("modbusM: TX WR: ");
	int x; for (x=0;x<8;x++) modbus_printf("0x%x ", modbus.querie[x]);
	modbus_printf(CMD_TERMINATOR);
	#endif

    return pdPASS;
    34cc:	e000      	b.n	34d0 <modbus_MasterWriteRegister+0x78>
//					errMODBUS_BUSY: Sinaliza que o gerenciador está no processo de comunicação com o escravo
//  				errMODBUS_XXXXX: Notificar ao sistema o tipo de erro e tomar procedimento cabíveis.
//						sistema deve consultar com a função modbus_MasterReadStatus()
// -------------------------------------------------------------------------------------------------------------------
int modbus_MasterWriteRegister(int addrSlave, int addr, u16 value) {
	if (modbus.waitResponse) return pdFAIL;
    34ce:	2500      	movs	r5, #0
	int x; for (x=0;x<8;x++) modbus_printf("0x%x ", modbus.querie[x]);
	modbus_printf(CMD_TERMINATOR);
	#endif

    return pdPASS;
}
    34d0:	4628      	mov	r0, r5
    34d2:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    34d6:	bf00      	nop
    34d8:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_MasterProcess:

000034dc <modbus_MasterProcess>:

// -------------------------------------------------------------------------------------------------------------------
// FUNÇÃO:		modbus_MasterProcess
// Descrição: 	Processa as respostas do escravo mediante as requisiççies de comandos
// -------------------------------------------------------------------------------------------------------------------
void modbus_MasterProcess(void) {
    34dc:	b573      	push	{r0, r1, r4, r5, r6, lr}
	static int len = 0;
    static int firstByte = pdTRUE;

    u8 dat;

	if (!modbus.waitResponse) {
    34de:	4c63      	ldr	r4, [pc, #396]	; (366c <modbus_MasterProcess+0x190>)
    34e0:	f8d4 3118 	ldr.w	r3, [r4, #280]	; 0x118
    34e4:	4625      	mov	r5, r4
    34e6:	b943      	cbnz	r3, 34fa <modbus_MasterProcess+0x1e>
		len = 0;
    34e8:	4a61      	ldr	r2, [pc, #388]	; (3670 <modbus_MasterProcess+0x194>)
    34ea:	6013      	str	r3, [r2, #0]
		firstByte = pdTRUE;
    34ec:	4b61      	ldr	r3, [pc, #388]	; (3674 <modbus_MasterProcess+0x198>)
    34ee:	2201      	movs	r2, #1
    34f0:	601a      	str	r2, [r3, #0]
		modbus.tout = modbus.timeout;
    34f2:	68e3      	ldr	r3, [r4, #12]
    34f4:	f8c4 311c 	str.w	r3, [r4, #284]	; 0x11c
    34f8:	e0b6      	b.n	3668 <modbus_MasterProcess+0x18c>
		return 0;
	}

    if (modbus.gc(&dat) == pdPASS) { 			// Checa se recebeu dados
    34fa:	6863      	ldr	r3, [r4, #4]
    34fc:	f10d 0007 	add.w	r0, sp, #7
    3500:	4798      	blx	r3
    3502:	2801      	cmp	r0, #1
    3504:	d110      	bne.n	3528 <modbus_MasterProcess+0x4c>
        #if (MODBUSM_USE_DEBUG == pdON)
        modbus_printf("modbusM: getp dat 0x%x [%c] len %d"CMD_TERMINATOR, dat, dat, len);
        #endif

		firstByte = pdFALSE;                    // Sinaliza que não é o mais o primeiro byte
    3506:	4b5b      	ldr	r3, [pc, #364]	; (3674 <modbus_MasterProcess+0x198>)
    3508:	2200      	movs	r2, #0
    350a:	601a      	str	r2, [r3, #0]

    	if (len >= 256) return errMODBUS_BUFFER_OVERFLOW;
    350c:	4a58      	ldr	r2, [pc, #352]	; (3670 <modbus_MasterProcess+0x194>)
    350e:	6813      	ldr	r3, [r2, #0]
    3510:	2bff      	cmp	r3, #255	; 0xff
    3512:	dc2c      	bgt.n	356e <modbus_MasterProcess+0x92>
        modbus.querie[len++] = dat;			// Adiciona o dado no buffer e aponta para o próximo indice do buffer
    3514:	1c59      	adds	r1, r3, #1
    3516:	6011      	str	r1, [r2, #0]
    3518:	f89d 2007 	ldrb.w	r2, [sp, #7]
    351c:	4423      	add	r3, r4
    351e:	741a      	strb	r2, [r3, #16]
		modbus.timeDataIn = modbusTIME_DATE_IN;			// Tempo de espera de recebimento de dados do escravo
    3520:	23c8      	movs	r3, #200	; 0xc8
    3522:	f8c4 3120 	str.w	r3, [r4, #288]	; 0x120
    3526:	e09f      	b.n	3668 <modbus_MasterProcess+0x18c>

 	// se não há mais bytes no buffer serial em um determinado tempo é porque é fim de transmissão
 		// valor 10 funciona bem entre 2400 a 115200 bps. Valor 5 funcionou bem com 57600 e 115200
        // para boudrate menores pode ser que devemos aumetar esse valor.
        // Recomendo fazer uma macro associado ao baudrate da serial
 	} else if (modbus.timeDataIn == 0) {
    3528:	f8d4 3120 	ldr.w	r3, [r4, #288]	; 0x120
    352c:	2b00      	cmp	r3, #0
    352e:	f040 809b 	bne.w	3668 <modbus_MasterProcess+0x18c>
        if (!firstByte) {
    3532:	4b50      	ldr	r3, [pc, #320]	; (3674 <modbus_MasterProcess+0x198>)
    3534:	681b      	ldr	r3, [r3, #0]
    3536:	b99b      	cbnz	r3, 3560 <modbus_MasterProcess+0x84>
        	if (len < 3) {
    3538:	4c4d      	ldr	r4, [pc, #308]	; (3670 <modbus_MasterProcess+0x194>)
    353a:	6821      	ldr	r1, [r4, #0]
    353c:	2902      	cmp	r1, #2
    353e:	dd19      	ble.n	3574 <modbus_MasterProcess+0x98>
        		return errMODBUS_LENPACKET;
        	}

            // Vamos pegar o pacote deste buffer e calcular e verificar a legitimidade
            // Calcular CRC do pacote e comparar
            u16 crc_calc = crc16_MODBUS(modbus.querie, len-2);
    3540:	3902      	subs	r1, #2
    3542:	f105 0010 	add.w	r0, r5, #16
    3546:	f7ff fef6 	bl	3336 <crc16_MODBUS>
            u16 crc = (modbus.querie[len-1] << 8 ) | modbus.querie[len-2];
    354a:	6823      	ldr	r3, [r4, #0]
    354c:	442b      	add	r3, r5
            if (crc != crc_calc) {
    354e:	7bda      	ldrb	r2, [r3, #15]
    3550:	7b9b      	ldrb	r3, [r3, #14]
    3552:	ea43 2302 	orr.w	r3, r3, r2, lsl #8
    3556:	4298      	cmp	r0, r3
    3558:	d00f      	beq.n	357a <modbus_MasterProcess+0x9e>
		        #if (MODBUSM_USE_DEBUG == pdON)
        		modbus_printf("modbusM: err crc 0x%x calc 0x%x len %d"CMD_TERMINATOR, crc, crc_calc, len);
        		#endif

            	return errMODBUS_CRC;
    355a:	f06f 0379 	mvn.w	r3, #121	; 0x79
    355e:	e00d      	b.n	357c <modbus_MasterProcess+0xa0>
            } else return pdPASS;

        // se ainda não recebemos o primeiro byte após um tempo vamos cancelar
        } else if (modbus.tout == 0) {
    3560:	f8d4 311c 	ldr.w	r3, [r4, #284]	; 0x11c
    3564:	2b00      	cmp	r3, #0
    3566:	d17f      	bne.n	3668 <modbus_MasterProcess+0x18c>
			#if (MODBUSM_USE_DEBUG == pdON)
        	modbus_printf("modbusM: err timeout"CMD_TERMINATOR);
        	#endif

			return errMODBUS_TIMEOUT;
    3568:	f06f 037b 	mvn.w	r3, #123	; 0x7b
    356c:	e006      	b.n	357c <modbus_MasterProcess+0xa0>
        modbus_printf("modbusM: getp dat 0x%x [%c] len %d"CMD_TERMINATOR, dat, dat, len);
        #endif

		firstByte = pdFALSE;                    // Sinaliza que não é o mais o primeiro byte

    	if (len >= 256) return errMODBUS_BUFFER_OVERFLOW;
    356e:	f06f 037c 	mvn.w	r3, #124	; 0x7c
    3572:	e003      	b.n	357c <modbus_MasterProcess+0xa0>
        	if (len < 3) {
		        #if (MODBUSM_USE_DEBUG == pdON)
        		modbus_printf("modbusM: err len %d"CMD_TERMINATOR, len);
        		#endif

        		return errMODBUS_LENPACKET;
    3574:	f06f 037d 	mvn.w	r3, #125	; 0x7d
    3578:	e000      	b.n	357c <modbus_MasterProcess+0xa0>
		        #if (MODBUSM_USE_DEBUG == pdON)
        		modbus_printf("modbusM: err crc 0x%x calc 0x%x len %d"CMD_TERMINATOR, crc, crc_calc, len);
        		#endif

            	return errMODBUS_CRC;
            } else return pdPASS;
    357a:	2301      	movs	r3, #1
    357c:	2b00      	cmp	r3, #0
		//  	errMODBUS_LENPACKET
		//  	errMODBUS_CRC
		//  	errMODBUS_TIMEOUT

	if (ret == 0 ) return;
   	if (ret < 0 ) {
    357e:	da05      	bge.n	358c <modbus_MasterProcess+0xb0>
   		modbus.sts = ret; 				// salva o erro
    3580:	f8c5 3134 	str.w	r3, [r5, #308]	; 0x134
   		modbus.waitResponse = pdFALSE; 	// sinaliza que não estamos esperando pela resposta do escravo
    3584:	2300      	movs	r3, #0
    3586:	f8c5 3118 	str.w	r3, [r5, #280]	; 0x118
    358a:	e06d      	b.n	3668 <modbus_MasterProcess+0x18c>
	} else {
		if (modbus.cmd == 3) 		modbus.sts = ProcessCmd3();	// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_LEN
    358c:	f8d5 3114 	ldr.w	r3, [r5, #276]	; 0x114
    3590:	4c36      	ldr	r4, [pc, #216]	; (366c <modbus_MasterProcess+0x190>)
    3592:	2b03      	cmp	r3, #3
    3594:	d12d      	bne.n	35f2 <modbus_MasterProcess+0x116>
//				errMODBUS_EXCEPTION: Sinaliza que o escravo enviou uma exceção, consultar status
//				errMODBUS_LEN: O tamanho do pacote recebido do escravo não confere ao esperado
// -------------------------------------------------------------------------------------------------------------------
static int ProcessCmd3(void) {
   	// Checa se este pacote é mesmo do escravo solicitado
   	int ret = ValidatePacket(); // retorna pdPASS	errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION
    3596:	f7ff fed5 	bl	3344 <ValidatePacket>
   	if (ret != pdPASS ) return ret;
    359a:	2801      	cmp	r0, #1
    359c:	d162      	bne.n	3664 <modbus_MasterProcess+0x188>
	modbus.cmd = 0; // sinaliza que não estamos mais operando nenhum comando
  	modbus.waitResponse = pdFALSE; // sinaliza que não estamos esperando pela resposta do escravo

	// captura a quantidade de bytes recebidos
   	int countBytes = modbus.querie[2];
   	if (2*modbus.len != countBytes) return errMODBUS_LEN;
    359e:	f8d4 2128 	ldr.w	r2, [r4, #296]	; 0x128
    35a2:	7ca1      	ldrb	r1, [r4, #18]
static int ProcessCmd3(void) {
   	// Checa se este pacote é mesmo do escravo solicitado
   	int ret = ValidatePacket(); // retorna pdPASS	errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION
   	if (ret != pdPASS ) return ret;

	modbus.cmd = 0; // sinaliza que não estamos mais operando nenhum comando
    35a4:	2300      	movs	r3, #0
  	modbus.waitResponse = pdFALSE; // sinaliza que não estamos esperando pela resposta do escravo

	// captura a quantidade de bytes recebidos
   	int countBytes = modbus.querie[2];
   	if (2*modbus.len != countBytes) return errMODBUS_LEN;
    35a6:	ebb1 0f42 	cmp.w	r1, r2, lsl #1
static int ProcessCmd3(void) {
   	// Checa se este pacote é mesmo do escravo solicitado
   	int ret = ValidatePacket(); // retorna pdPASS	errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION
   	if (ret != pdPASS ) return ret;

	modbus.cmd = 0; // sinaliza que não estamos mais operando nenhum comando
    35aa:	f8c4 3114 	str.w	r3, [r4, #276]	; 0x114
  	modbus.waitResponse = pdFALSE; // sinaliza que não estamos esperando pela resposta do escravo
    35ae:	f8c4 3118 	str.w	r3, [r4, #280]	; 0x118

	// captura a quantidade de bytes recebidos
   	int countBytes = modbus.querie[2];
   	if (2*modbus.len != countBytes) return errMODBUS_LEN;
    35b2:	d11b      	bne.n	35ec <modbus_MasterProcess+0x110>
    35b4:	4618      	mov	r0, r3
    35b6:	f8d4 1124 	ldr.w	r1, [r4, #292]	; 0x124
    35ba:	3413      	adds	r4, #19

	// Tirar os valores dos registradores do bufferin para o buffer da aplicação
   	int x; for(x=0; x<modbus.len;x++)
    35bc:	4282      	cmp	r2, r0
    35be:	f104 0402 	add.w	r4, r4, #2
    35c2:	dd0a      	ble.n	35da <modbus_MasterProcess+0xfe>
       	*modbus.regs++ = (modbus.querie[2*x+3] << 8) | (modbus.querie[2*x+4]);
    35c4:	f814 6c02 	ldrb.w	r6, [r4, #-2]
    35c8:	f814 3c01 	ldrb.w	r3, [r4, #-1]
    35cc:	ea43 2306 	orr.w	r3, r3, r6, lsl #8
    35d0:	f821 3010 	strh.w	r3, [r1, r0, lsl #1]
	// captura a quantidade de bytes recebidos
   	int countBytes = modbus.querie[2];
   	if (2*modbus.len != countBytes) return errMODBUS_LEN;

	// Tirar os valores dos registradores do bufferin para o buffer da aplicação
   	int x; for(x=0; x<modbus.len;x++)
    35d4:	3001      	adds	r0, #1
    35d6:	2301      	movs	r3, #1
    35d8:	e7f0      	b.n	35bc <modbus_MasterProcess+0xe0>
    35da:	ea22 72e2 	bic.w	r2, r2, r2, asr #31
    35de:	eb01 0242 	add.w	r2, r1, r2, lsl #1
    35e2:	b10b      	cbz	r3, 35e8 <modbus_MasterProcess+0x10c>
    35e4:	f8c5 2124 	str.w	r2, [r5, #292]	; 0x124
       	*modbus.regs++ = (modbus.querie[2*x+3] << 8) | (modbus.querie[2*x+4]);

  	return pdPASS;
    35e8:	2001      	movs	r0, #1
    35ea:	e03b      	b.n	3664 <modbus_MasterProcess+0x188>
	modbus.cmd = 0; // sinaliza que não estamos mais operando nenhum comando
  	modbus.waitResponse = pdFALSE; // sinaliza que não estamos esperando pela resposta do escravo

	// captura a quantidade de bytes recebidos
   	int countBytes = modbus.querie[2];
   	if (2*modbus.len != countBytes) return errMODBUS_LEN;
    35ec:	f06f 0082 	mvn.w	r0, #130	; 0x82
    35f0:	e038      	b.n	3664 <modbus_MasterProcess+0x188>
   	if (ret < 0 ) {
   		modbus.sts = ret; 				// salva o erro
   		modbus.waitResponse = pdFALSE; 	// sinaliza que não estamos esperando pela resposta do escravo
	} else {
		if (modbus.cmd == 3) 		modbus.sts = ProcessCmd3();	// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_LEN
		else if (modbus.cmd == 6) 	modbus.sts = ProcessCmd6();	// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_ADDR errMODBUS_VALUE
    35f2:	2b06      	cmp	r3, #6
    35f4:	d117      	bne.n	3626 <modbus_MasterProcess+0x14a>
//				errMODBUS_EXCEPTION: Sinaliza que o escravo enviou uma exceção, consultar status
//				errMODBUS_LEN: O tamanho do pacote recebido do escravo não confere ao esperado
// -------------------------------------------------------------------------------------------------------------------
static int ProcessCmd6(void) {
   	// Checa se este pacote é mesmo do escravo solicitado
   	int ret = ValidatePacket(); // retorna pdPASS	errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION
    35f6:	f7ff fea5 	bl	3344 <ValidatePacket>
   	if (ret != pdPASS ) return ret;
    35fa:	2801      	cmp	r0, #1
    35fc:	d132      	bne.n	3664 <modbus_MasterProcess+0x188>

	modbus.cmd = 0; // sinaliza que não estamos mais operando nenhum comando
    35fe:	2300      	movs	r3, #0
    3600:	f8c4 3114 	str.w	r3, [r4, #276]	; 0x114
  	modbus.waitResponse = pdFALSE; // sinaliza que não estamos esperando pela resposta do escravo
    3604:	f8c4 3118 	str.w	r3, [r4, #280]	; 0x118

	// compara endereço do registrador
    int addrComp = (modbus.querie[2] << 8) | (modbus.querie[3]);
    if (modbus.addr != addrComp)  return errMODBUS_ADDR;
    3608:	8a63      	ldrh	r3, [r4, #18]
    360a:	f8d4 212c 	ldr.w	r2, [r4, #300]	; 0x12c
    360e:	ba5b      	rev16	r3, r3
    3610:	b29b      	uxth	r3, r3
    3612:	4293      	cmp	r3, r2
    3614:	d124      	bne.n	3660 <modbus_MasterProcess+0x184>

    // compara valor do registrador
    u16 valueComp = (modbus.querie[4] << 8) | (modbus.querie[5]);
    if (modbus.value != valueComp) return errMODBUS_VALUE;
    3616:	7d21      	ldrb	r1, [r4, #20]
    3618:	7d63      	ldrb	r3, [r4, #21]
    361a:	f8b4 2130 	ldrh.w	r2, [r4, #304]	; 0x130
    361e:	ea43 2301 	orr.w	r3, r3, r1, lsl #8
    3622:	429a      	cmp	r2, r3
    3624:	e017      	b.n	3656 <modbus_MasterProcess+0x17a>
   		modbus.sts = ret; 				// salva o erro
   		modbus.waitResponse = pdFALSE; 	// sinaliza que não estamos esperando pela resposta do escravo
	} else {
		if (modbus.cmd == 3) 		modbus.sts = ProcessCmd3();	// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_LEN
		else if (modbus.cmd == 6) 	modbus.sts = ProcessCmd6();	// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_ADDR errMODBUS_VALUE
		else if (modbus.cmd == 16) 	modbus.sts = ProcessCmd16();// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_ADDR errMODBUS_VALUE
    3626:	2b10      	cmp	r3, #16
    3628:	d11e      	bne.n	3668 <modbus_MasterProcess+0x18c>
//				errMODBUS_EXCEPTION: Sinaliza que o escravo enviou uma exceção, consultar status
//				errMODBUS_LEN: O tamanho do pacote recebido do escravo não confere ao esperado
// -------------------------------------------------------------------------------------------------------------------
static int ProcessCmd16(void) {
   	// Checa se este pacote é mesmo do escravo solicitado
   	int ret = ValidatePacket(); // retorna pdPASS	errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION
    362a:	f7ff fe8b 	bl	3344 <ValidatePacket>
   	if (ret != pdPASS ) return ret;
    362e:	2801      	cmp	r0, #1
    3630:	d118      	bne.n	3664 <modbus_MasterProcess+0x188>

	modbus.cmd = 0; // sinaliza que não estamos mais operando nenhum comando
    3632:	2300      	movs	r3, #0
    3634:	f8c4 3114 	str.w	r3, [r4, #276]	; 0x114
  	modbus.waitResponse = pdFALSE; // sinaliza que não estamos esperando pela resposta do escravo
    3638:	f8c4 3118 	str.w	r3, [r4, #280]	; 0x118

	// compara endereço do registrador
    int cmp = (modbus.querie[2] << 8) | (modbus.querie[3]);
    if (modbus.addr != cmp)  return errMODBUS_ADDR;
    363c:	8a63      	ldrh	r3, [r4, #18]
    363e:	f8d4 212c 	ldr.w	r2, [r4, #300]	; 0x12c
    3642:	ba5b      	rev16	r3, r3
    3644:	b29b      	uxth	r3, r3
    3646:	4293      	cmp	r3, r2
    3648:	d10a      	bne.n	3660 <modbus_MasterProcess+0x184>

    // compara a quantidade
    cmp = (modbus.querie[4] << 8) | (modbus.querie[5]);
    if (modbus.len != cmp) return errMODBUS_VALUE;
    364a:	8aa3      	ldrh	r3, [r4, #20]
    364c:	f8d4 2128 	ldr.w	r2, [r4, #296]	; 0x128
    3650:	ba5b      	rev16	r3, r3
    3652:	b29b      	uxth	r3, r3
    3654:	4293      	cmp	r3, r2
    3656:	bf0c      	ite	eq
    3658:	2001      	moveq	r0, #1
    365a:	f06f 0083 	mvnne.w	r0, #131	; 0x83
    365e:	e001      	b.n	3664 <modbus_MasterProcess+0x188>
	modbus.cmd = 0; // sinaliza que não estamos mais operando nenhum comando
  	modbus.waitResponse = pdFALSE; // sinaliza que não estamos esperando pela resposta do escravo

	// compara endereço do registrador
    int cmp = (modbus.querie[2] << 8) | (modbus.querie[3]);
    if (modbus.addr != cmp)  return errMODBUS_ADDR;
    3660:	f06f 007f 	mvn.w	r0, #127	; 0x7f
   		modbus.sts = ret; 				// salva o erro
   		modbus.waitResponse = pdFALSE; 	// sinaliza que não estamos esperando pela resposta do escravo
	} else {
		if (modbus.cmd == 3) 		modbus.sts = ProcessCmd3();	// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_LEN
		else if (modbus.cmd == 6) 	modbus.sts = ProcessCmd6();	// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_ADDR errMODBUS_VALUE
		else if (modbus.cmd == 16) 	modbus.sts = ProcessCmd16();// retorna	pdPASS errMODBUS_ID	errMODBUS_CMD errMODBUS_EXCEPTION errMODBUS_ADDR errMODBUS_VALUE
    3664:	f8c5 0134 	str.w	r0, [r5, #308]	; 0x134
	}
}
    3668:	b002      	add	sp, #8
    366a:	bd70      	pop	{r4, r5, r6, pc}
    366c:	10000b58 	.word	0x10000b58
    3670:	10000dc0 	.word	0x10000dc0
    3674:	10000008 	.word	0x10000008

Disassembly of section .text.modbus_MasterTick:

00003678 <modbus_MasterTick>:

//-----------------------------------------------------------------------------------------------------------------------
// Esta função deve ser chamada a cada 1ms
//-----------------------------------------------------------------------------------------------------------------------
void modbus_MasterTick(void) {
	if (modbus.tout) modbus.tout--;
    3678:	4b09      	ldr	r3, [pc, #36]	; (36a0 <modbus_MasterTick+0x28>)
    367a:	f8d3 211c 	ldr.w	r2, [r3, #284]	; 0x11c
    367e:	b122      	cbz	r2, 368a <modbus_MasterTick+0x12>
    3680:	f8d3 211c 	ldr.w	r2, [r3, #284]	; 0x11c
    3684:	3a01      	subs	r2, #1
    3686:	f8c3 211c 	str.w	r2, [r3, #284]	; 0x11c
	if (modbus.timeDataIn) modbus.timeDataIn--;
    368a:	f8d3 3120 	ldr.w	r3, [r3, #288]	; 0x120
    368e:	4a04      	ldr	r2, [pc, #16]	; (36a0 <modbus_MasterTick+0x28>)
    3690:	b123      	cbz	r3, 369c <modbus_MasterTick+0x24>
    3692:	f8d2 3120 	ldr.w	r3, [r2, #288]	; 0x120
    3696:	3b01      	subs	r3, #1
    3698:	f8c2 3120 	str.w	r3, [r2, #288]	; 0x120
    369c:	4770      	bx	lr
    369e:	bf00      	nop
    36a0:	10000b58 	.word	0x10000b58

Disassembly of section .text.modbus_SendPacketException:

000036a4 <modbus_SendPacketException>:
// FUNÇÃO:		modbus_SendPacketException
// Descrição: 	Envia uma mensagem de exceção para o mestre
// Parametros:	exception: Código da exceção
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketException(int exception) {
    36a4:	b570      	push	{r4, r5, r6, lr}
	modbus.query[0] = modbus.slaveID;
    36a6:	4c0b      	ldr	r4, [pc, #44]	; (36d4 <modbus_SendPacketException+0x30>)
	modbus.query[1] = 0x80 + modbus.cmd;
	modbus.query[2] = exception;
	uint crc = crc16_MODBUS(modbus.query, 3);
    36a8:	2103      	movs	r1, #3
// Descrição: 	Envia uma mensagem de exceção para o mestre
// Parametros:	exception: Código da exceção
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketException(int exception) {
	modbus.query[0] = modbus.slaveID;
    36aa:	6823      	ldr	r3, [r4, #0]
	modbus.query[1] = 0x80 + modbus.cmd;
	modbus.query[2] = exception;
	uint crc = crc16_MODBUS(modbus.query, 3);
    36ac:	f104 0518 	add.w	r5, r4, #24
// Descrição: 	Envia uma mensagem de exceção para o mestre
// Parametros:	exception: Código da exceção
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketException(int exception) {
	modbus.query[0] = modbus.slaveID;
    36b0:	7623      	strb	r3, [r4, #24]
	modbus.query[1] = 0x80 + modbus.cmd;
    36b2:	f8d4 3118 	ldr.w	r3, [r4, #280]	; 0x118
	modbus.query[2] = exception;
    36b6:	76a0      	strb	r0, [r4, #26]
// Parametros:	exception: Código da exceção
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketException(int exception) {
	modbus.query[0] = modbus.slaveID;
	modbus.query[1] = 0x80 + modbus.cmd;
    36b8:	3b80      	subs	r3, #128	; 0x80
	modbus.query[2] = exception;
	uint crc = crc16_MODBUS(modbus.query, 3);
    36ba:	4628      	mov	r0, r5
// Parametros:	exception: Código da exceção
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketException(int exception) {
	modbus.query[0] = modbus.slaveID;
	modbus.query[1] = 0x80 + modbus.cmd;
    36bc:	7663      	strb	r3, [r4, #25]
	modbus.query[2] = exception;
	uint crc = crc16_MODBUS(modbus.query, 3);
    36be:	f7ff fe3a 	bl	3336 <crc16_MODBUS>
	modbus.query[3] = (u8)(crc&0xFF);
    36c2:	76e0      	strb	r0, [r4, #27]
	modbus.query[4] = (u8)(crc>>8);
    36c4:	0a00      	lsrs	r0, r0, #8
    36c6:	7720      	strb	r0, [r4, #28]

	modbus.puts(modbus.query, 5);
    36c8:	6863      	ldr	r3, [r4, #4]
    36ca:	4628      	mov	r0, r5
    plognp("MODBUS: SEND EXCPETION: ");
    int db_x; for(db_x=0;db_x<5;db_x++) plognp("0x%x ", modbus.query[db_x]);
    plognp(CMD_TERMINATOR);
    plognp("MODBUS: crc 0x%x"CMD_TERMINATOR, crc);
    #endif
}
    36cc:	e8bd 4070 	ldmia.w	sp!, {r4, r5, r6, lr}
	modbus.query[2] = exception;
	uint crc = crc16_MODBUS(modbus.query, 3);
	modbus.query[3] = (u8)(crc&0xFF);
	modbus.query[4] = (u8)(crc>>8);

	modbus.puts(modbus.query, 5);
    36d0:	2105      	movs	r1, #5
    36d2:	4718      	bx	r3
    36d4:	10000c94 	.word	0x10000c94

Disassembly of section .text.modbus_SlaveInit:

000036d8 <modbus_SlaveInit>:
	int slaveID,
	int(*puts_func)(u8* buffer, u16 count),
	int(*getc_func)(u8* ch),
	int(*byte_available_func)(void),
	void(*flushRX_func)(void)
) {
    36d8:	b510      	push	{r4, lr}

	modbus.slaveID = slaveID;
    36da:	4c08      	ldr	r4, [pc, #32]	; (36fc <modbus_SlaveInit+0x24>)
	modbus.puts = puts_func;
	modbus.getc = getc_func;
	modbus.byteAvailable = byte_available_func;
    36dc:	e884 000f 	stmia.w	r4, {r0, r1, r2, r3}
	modbus.flushRX = flushRX_func;
    36e0:	9b02      	ldr	r3, [sp, #8]
    36e2:	6123      	str	r3, [r4, #16]
	modbus.lastLenBuffer = 0;
    36e4:	2300      	movs	r3, #0
    36e6:	f8c4 311c 	str.w	r3, [r4, #284]	; 0x11c
	modbus.timeout = 0;
    36ea:	6163      	str	r3, [r4, #20]

	modbus.read_regs = NULL;
    36ec:	f8c4 3120 	str.w	r3, [r4, #288]	; 0x120
	modbus.write_reg = NULL;
    36f0:	f8c4 3124 	str.w	r3, [r4, #292]	; 0x124
	modbus.write_regs = NULL;
    36f4:	f8c4 3128 	str.w	r3, [r4, #296]	; 0x128
    36f8:	bd10      	pop	{r4, pc}
    36fa:	bf00      	nop
    36fc:	10000c94 	.word	0x10000c94

Disassembly of section .text.modbus_SlaveAppendFunctions:

00003700 <modbus_SlaveAppendFunctions>:
void modbus_SlaveAppendFunctions(
	int (*readregs_func)(uint addrInit, u8* query, uint count),
	int (*writereg_func)(uint addr, u16 value),
	int (*writeregs_func)(uint addrInit, u8* query, uint count)
) {
	modbus.read_regs = readregs_func;
    3700:	4b03      	ldr	r3, [pc, #12]	; (3710 <modbus_SlaveAppendFunctions+0x10>)
    3702:	f8c3 0120 	str.w	r0, [r3, #288]	; 0x120
	modbus.write_reg = writereg_func;
    3706:	f8c3 1124 	str.w	r1, [r3, #292]	; 0x124
	modbus.write_regs = writeregs_func;
    370a:	f8c3 2128 	str.w	r2, [r3, #296]	; 0x128
    370e:	4770      	bx	lr
    3710:	10000c94 	.word	0x10000c94

Disassembly of section .text.modbus_SlaveProcess:

00003714 <modbus_SlaveProcess>:
// -------------------------------------------------------------------------------------------------------------------
// exemplos de pacotes
// 		len	  	 0    1    2	3    4    5    6    7
// 			 	0x01 0x03 0x00 0x00 0x00 0x02 0xC4 0x0B 	lendo dois regs no device 1 addr 2
//				0x04 0x03 0x00 0x0F 0x00 0x02 0xF4 0x5D		lendo dois regs no device 4 addr 2
int modbus_SlaveProcess(void) {
    3714:	b5f7      	push	{r0, r1, r2, r4, r5, r6, r7, lr}
   	int len = modbus.byteAvailable();
    3716:	4c56      	ldr	r4, [pc, #344]	; (3870 <modbus_SlaveProcess+0x15c>)
    3718:	68e3      	ldr	r3, [r4, #12]
    371a:	4798      	blx	r3
    371c:	4626      	mov	r6, r4

   	// se não há nada no buffer não fazemos nada
    if ( len == 0 ) {
    371e:	b910      	cbnz	r0, 3726 <modbus_SlaveProcess+0x12>
    	modbus.lastLenBuffer = 0;
    3720:	f8c4 011c 	str.w	r0, [r4, #284]	; 0x11c
        return pdFAIL;
    3724:	e0a1      	b.n	386a <modbus_SlaveProcess+0x156>
    }

    // reinicia o timeout caso o buffer de recepção vai aumentando
    // se estourar o buffer o driver serial se encarrega disso, e neste caso não processamos nada
    // mesmo com o buffer cheio com dados lixo os dados serão todos processados e o CRC não vai bater e tudo será descartado
    if (modbus.lastLenBuffer != len) {
    3726:	f8d4 311c 	ldr.w	r3, [r4, #284]	; 0x11c
    372a:	4298      	cmp	r0, r3
    372c:	d004      	beq.n	3738 <modbus_SlaveProcess+0x24>
    	modbus.lastLenBuffer = len;
        modbus.timeout = 100; // valor 10 funciona bem entre 2400 a 115200 bps. Valor 5 funcionou bem com 57600 e 115200
    372e:	2364      	movs	r3, #100	; 0x64

    // reinicia o timeout caso o buffer de recepção vai aumentando
    // se estourar o buffer o driver serial se encarrega disso, e neste caso não processamos nada
    // mesmo com o buffer cheio com dados lixo os dados serão todos processados e o CRC não vai bater e tudo será descartado
    if (modbus.lastLenBuffer != len) {
    	modbus.lastLenBuffer = len;
    3730:	f8c4 011c 	str.w	r0, [r4, #284]	; 0x11c
        modbus.timeout = 100; // valor 10 funciona bem entre 2400 a 115200 bps. Valor 5 funcionou bem com 57600 e 115200
    3734:	6163      	str	r3, [r4, #20]
    3736:	e097      	b.n	3868 <modbus_SlaveProcess+0x154>
        									// Recomendo fazer uma macro associado ao boudrate da serial
        return pdFAIL;
    }

    // somente vamos processar quando estourar o timeout de recepção
    if (modbus.timeout) return pdFAIL;
    3738:	6965      	ldr	r5, [r4, #20]
    373a:	2d00      	cmp	r5, #0
    373c:	f040 8094 	bne.w	3868 <modbus_SlaveProcess+0x154>
	// faço enquanto há dados no buffer de recepção
	#if (MODBUS_USE_DEBUG == pdON)
	plognp("MODBUS: GET PACKET: ");
	#endif

	while (modbus.getc(&ch) == pdPASS) {
    3740:	4627      	mov	r7, r4

    // somente vamos processar quando estourar o timeout de recepção
    if (modbus.timeout) return pdFAIL;

   	// processando o pacote
   	modbus.lastLenBuffer = 0;
    3742:	f8c4 511c 	str.w	r5, [r4, #284]	; 0x11c
	// faço enquanto há dados no buffer de recepção
	#if (MODBUS_USE_DEBUG == pdON)
	plognp("MODBUS: GET PACKET: ");
	#endif

	while (modbus.getc(&ch) == pdPASS) {
    3746:	68b3      	ldr	r3, [r6, #8]
    3748:	f10d 0007 	add.w	r0, sp, #7
    374c:	4798      	blx	r3
    374e:	2801      	cmp	r0, #1
    3750:	4c47      	ldr	r4, [pc, #284]	; (3870 <modbus_SlaveProcess+0x15c>)
    3752:	d108      	bne.n	3766 <modbus_SlaveProcess+0x52>
		if (len > 255) return errMODBUS_BUFRX_OVERFLOW;
    3754:	f5b5 7f80 	cmp.w	r5, #256	; 0x100
    3758:	d01b      	beq.n	3792 <modbus_SlaveProcess+0x7e>
		query[len++] = ch;
    375a:	3501      	adds	r5, #1
    375c:	f89d 2007 	ldrb.w	r2, [sp, #7]
    3760:	197b      	adds	r3, r7, r5
    3762:	75da      	strb	r2, [r3, #23]
    3764:	e7ef      	b.n	3746 <modbus_SlaveProcess+0x32>
		plognp("0x%x ", ch);
		#endif
	}

	// o menor pacote é de 4 bytes
	if (len < 4) {
    3766:	2d03      	cmp	r5, #3
    3768:	dd13      	ble.n	3792 <modbus_SlaveProcess+0x7e>

		return errMODBUS_BUFRX_INCOMPLETE;
	}

	// processar CRC
	len-=2; // desconsidera o CRC
    376a:	3d02      	subs	r5, #2
	uint crc = crc16_MODBUS(query, len);
    376c:	4629      	mov	r1, r5
    376e:	f104 0018 	add.w	r0, r4, #24
    3772:	f7ff fde0 	bl	3336 <crc16_MODBUS>
	uint crc_rx = ( query[len+1] << 8) | (query[len]);
    3776:	1962      	adds	r2, r4, r5
    int db_x; for(db_x=0;db_x<len;db_x++) plognp("0x%x ", query[db_x]);
    plognp(CMD_TERMINATOR);
    plognp("MODBUS: crc 0x%x == 0x%x"CMD_TERMINATOR, crc_rx, crc);
    #endif

	if (crc != crc_rx) return errMODBUS_CRC;
    3778:	7e51      	ldrb	r1, [r2, #25]
    377a:	7e13      	ldrb	r3, [r2, #24]
    377c:	ea43 2301 	orr.w	r3, r3, r1, lsl #8
    3780:	4298      	cmp	r0, r3
    3782:	d106      	bne.n	3792 <modbus_SlaveProcess+0x7e>

	len = modbus_GetPacket(modbus.query);

    // se houve erro de CRC ou overflow do buffer, ou o endereço na mensagem é para este dispositivo
    // o menor pacote é 4 bytes (1 byte ID, 1 byte função e 2 bytes CRC), porém no modbus.query não vai conter CRC
    if ( (len < 1) || (modbus.query[0] != modbus.slaveID) ) {
    3784:	2d00      	cmp	r5, #0
    3786:	dd04      	ble.n	3792 <modbus_SlaveProcess+0x7e>
    3788:	7e32      	ldrb	r2, [r6, #24]
    378a:	6833      	ldr	r3, [r6, #0]
    378c:	4625      	mov	r5, r4
    378e:	429a      	cmp	r2, r3
    3790:	d002      	beq.n	3798 <modbus_SlaveProcess+0x84>
	    #if (MODBUS_USE_DEBUG == pdON)
    	plognp("MODBUS: pck error"CMD_TERMINATOR);
    	#endif
		modbus.flushRX();
    3792:	6933      	ldr	r3, [r6, #16]
    3794:	4798      	blx	r3
    3796:	e067      	b.n	3868 <modbus_SlaveProcess+0x154>
    };

	int ret;
	uint addrInit; // Não podemos colocar a captura do addr aqui porque pode haver comandos simples

	modbus.cmd = modbus.query[1];
    3798:	7e63      	ldrb	r3, [r4, #25]

	// checa se a função é de leitura dos registradores, processa caso há função anexada
    if ( (modbus.cmd == modbusCMD_READ_REGISTERS) && (modbus.read_regs != NULL)) {
    379a:	2b03      	cmp	r3, #3
    };

	int ret;
	uint addrInit; // Não podemos colocar a captura do addr aqui porque pode haver comandos simples

	modbus.cmd = modbus.query[1];
    379c:	f8c4 3118 	str.w	r3, [r4, #280]	; 0x118

	// checa se a função é de leitura dos registradores, processa caso há função anexada
    if ( (modbus.cmd == modbusCMD_READ_REGISTERS) && (modbus.read_regs != NULL)) {
    37a0:	d125      	bne.n	37ee <modbus_SlaveProcess+0xda>
    37a2:	f8d4 7120 	ldr.w	r7, [r4, #288]	; 0x120
    37a6:	2f00      	cmp	r7, #0
    37a8:	d057      	beq.n	385a <modbus_SlaveProcess+0x146>
		addrInit = ((uint) modbus.query[2] << 8) + (uint)modbus.query[3];
		len = ((int) modbus.query[4] << 8) + (int)modbus.query[5];

		// chamar a função externa para capturar os dados
		// 	passo o endereço do buffer a partir do 4º byte, os tres primeiros são reservador para ID, função e count para tx mais tarde
		ret = modbus.read_regs(addrInit, &modbus.query[3], len);
    37aa:	4621      	mov	r1, r4
	modbus.cmd = modbus.query[1];

	// checa se a função é de leitura dos registradores, processa caso há função anexada
    if ( (modbus.cmd == modbusCMD_READ_REGISTERS) && (modbus.read_regs != NULL)) {
		addrInit = ((uint) modbus.query[2] << 8) + (uint)modbus.query[3];
		len = ((int) modbus.query[4] << 8) + (int)modbus.query[5];
    37ac:	7f63      	ldrb	r3, [r4, #29]
    37ae:	7f25      	ldrb	r5, [r4, #28]

		// chamar a função externa para capturar os dados
		// 	passo o endereço do buffer a partir do 4º byte, os tres primeiros são reservador para ID, função e count para tx mais tarde
		ret = modbus.read_regs(addrInit, &modbus.query[3], len);
    37b0:	7ea0      	ldrb	r0, [r4, #26]
	modbus.cmd = modbus.query[1];

	// checa se a função é de leitura dos registradores, processa caso há função anexada
    if ( (modbus.cmd == modbusCMD_READ_REGISTERS) && (modbus.read_regs != NULL)) {
		addrInit = ((uint) modbus.query[2] << 8) + (uint)modbus.query[3];
		len = ((int) modbus.query[4] << 8) + (int)modbus.query[5];
    37b2:	eb03 2505 	add.w	r5, r3, r5, lsl #8

		// chamar a função externa para capturar os dados
		// 	passo o endereço do buffer a partir do 4º byte, os tres primeiros são reservador para ID, função e count para tx mais tarde
		ret = modbus.read_regs(addrInit, &modbus.query[3], len);
    37b6:	f811 3f1b 	ldrb.w	r3, [r1, #27]!
    37ba:	462a      	mov	r2, r5
    37bc:	eb03 2000 	add.w	r0, r3, r0, lsl #8
    37c0:	47b8      	blx	r7
		if (ret == modbusNO_ERROR)
    37c2:	2800      	cmp	r0, #0
    37c4:	d14a      	bne.n	385c <modbus_SlaveProcess+0x148>
// Parametros:	query: Buffer já contendo os valores dos registradores
//				len: Quantidade de registradores de 16 bits
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketRegs(u8* query, int len) {
	query[0] = modbus.slaveID;
    37c6:	6823      	ldr	r3, [r4, #0]
	query[1] = modbus.cmd;
	query[2] = (u8)(2*len);
    37c8:	006d      	lsls	r5, r5, #1
// Parametros:	query: Buffer já contendo os valores dos registradores
//				len: Quantidade de registradores de 16 bits
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketRegs(u8* query, int len) {
	query[0] = modbus.slaveID;
    37ca:	7623      	strb	r3, [r4, #24]
	query[1] = modbus.cmd;
    37cc:	f8d4 3118 	ldr.w	r3, [r4, #280]	; 0x118
	query[2] = (u8)(2*len);
	uint crc = crc16_MODBUS(query, (2*len)+3);
    37d0:	1ce9      	adds	r1, r5, #3
//				len: Quantidade de registradores de 16 bits
// Retorna:		Nada
// -------------------------------------------------------------------------------------------------------------------
static void modbus_SendPacketRegs(u8* query, int len) {
	query[0] = modbus.slaveID;
	query[1] = modbus.cmd;
    37d2:	7663      	strb	r3, [r4, #25]
	query[2] = (u8)(2*len);
    37d4:	76a5      	strb	r5, [r4, #26]
	uint crc = crc16_MODBUS(query, (2*len)+3);
    37d6:	f104 0018 	add.w	r0, r4, #24
    37da:	f7ff fdac 	bl	3336 <crc16_MODBUS>
	query[(2*len)+3] = (u8)(crc&0xFF);
    37de:	1963      	adds	r3, r4, r5
    37e0:	76d8      	strb	r0, [r3, #27]
	query[(2*len)+4] = (u8)(crc>>8);
    37e2:	0a00      	lsrs	r0, r0, #8
    37e4:	7718      	strb	r0, [r3, #28]
	modbus.puts(query, (2*len)+5);
    37e6:	1d69      	adds	r1, r5, #5
    37e8:	6863      	ldr	r3, [r4, #4]
    37ea:	b289      	uxth	r1, r1
    37ec:	e012      	b.n	3814 <modbus_SlaveProcess+0x100>
			modbus_SendPacketRegs(modbus.query, len); // Envia os valores dos registradores
		else
			modbus_SendPacketException(ret);

    // checa se a função é de escrita no registrador, processa caso há função anexada
    } else if ( (modbus.cmd == modbusCMD_WRITE_REGISTER) && (modbus.write_reg != NULL)) {
    37ee:	2b06      	cmp	r3, #6
    37f0:	d114      	bne.n	381c <modbus_SlaveProcess+0x108>
    37f2:	f8d4 2124 	ldr.w	r2, [r4, #292]	; 0x124
    37f6:	2a00      	cmp	r2, #0
    37f8:	d02f      	beq.n	385a <modbus_SlaveProcess+0x146>
		// chamar a função externa gravar o registrador
		addrInit = ((uint) modbus.query[2] << 8) + (uint)modbus.query[3];
		u16 data = ((u16) modbus.query[4] << 8) + (u16)modbus.query[5];
		ret = modbus.write_reg(addrInit, data);
    37fa:	7f63      	ldrb	r3, [r4, #29]
    37fc:	7f21      	ldrb	r1, [r4, #28]
    37fe:	7ea0      	ldrb	r0, [r4, #26]
    3800:	eb03 2101 	add.w	r1, r3, r1, lsl #8
    3804:	7ee3      	ldrb	r3, [r4, #27]
    3806:	b289      	uxth	r1, r1
    3808:	eb03 2000 	add.w	r0, r3, r0, lsl #8
    380c:	4790      	blx	r2
		if (ret == modbusNO_ERROR)
    380e:	bb28      	cbnz	r0, 385c <modbus_SlaveProcess+0x148>
			modbus.puts(modbus.query, 8); // retorna o eco do pedido sinalizando ao mestre que tudo ocorreu bem
    3810:	6863      	ldr	r3, [r4, #4]
    3812:	2108      	movs	r1, #8
    3814:	f104 0018 	add.w	r0, r4, #24
    3818:	4798      	blx	r3
    381a:	e021      	b.n	3860 <modbus_SlaveProcess+0x14c>
		else
			modbus_SendPacketException(ret);

    // checa se a função é de escrita nos registradores, processa caso há função anexada
    } else if ( (modbus.cmd == modbusCMD_WRITE_REGISTERS) && (modbus.write_regs != NULL)) {
    381c:	2b10      	cmp	r3, #16
    381e:	d11c      	bne.n	385a <modbus_SlaveProcess+0x146>
    3820:	f8d4 4128 	ldr.w	r4, [r4, #296]	; 0x128
    3824:	b1cc      	cbz	r4, 385a <modbus_SlaveProcess+0x146>
    	addrInit = ((uint) modbus.query[2] << 8) + (uint)modbus.query[3];
    	len = ((int) modbus.query[4] << 8) + (int)modbus.query[5];
    3826:	7f6b      	ldrb	r3, [r5, #29]
    3828:	7f2a      	ldrb	r2, [r5, #28]
    382a:	eb03 2202 	add.w	r2, r3, r2, lsl #8
		// se a quantidade de registradores não corresponde com a quantidade de bytes no buffer retorna erro
		if (2*len != modbus.query[6]) ret = modbusILLEGAL_FUNCTION;
    382e:	7fab      	ldrb	r3, [r5, #30]
    3830:	ebb3 0f42 	cmp.w	r3, r2, lsl #1
    3834:	d111      	bne.n	385a <modbus_SlaveProcess+0x146>
		else
			// chamar a função externa gravar nos registradores
			// 	passo o endereço do buffer a partir do 7º byte onde começa os dados
			ret = modbus.write_regs(addrInit, &modbus.query[7], len);
    3836:	7ea8      	ldrb	r0, [r5, #26]
    3838:	7eeb      	ldrb	r3, [r5, #27]
    383a:	490e      	ldr	r1, [pc, #56]	; (3874 <modbus_SlaveProcess+0x160>)
    383c:	eb03 2000 	add.w	r0, r3, r0, lsl #8
    3840:	47a0      	blx	r4
		if (ret == modbusNO_ERROR) { // retorna o eco do pedido sinalizando ao mestre que tudo ocorreu bem
    3842:	b958      	cbnz	r0, 385c <modbus_SlaveProcess+0x148>
			uint crc = crc16_MODBUS(modbus.query, 6);
    3844:	2106      	movs	r1, #6
    3846:	480c      	ldr	r0, [pc, #48]	; (3878 <modbus_SlaveProcess+0x164>)
    3848:	f7ff fd75 	bl	3336 <crc16_MODBUS>
			modbus.query[6] = (u8)(crc&0xFF);
    384c:	77a8      	strb	r0, [r5, #30]
			modbus.query[7] = (u8)(crc>>8);
    384e:	0a00      	lsrs	r0, r0, #8
    3850:	77e8      	strb	r0, [r5, #31]
			modbus.puts(modbus.query, 8);
    3852:	686b      	ldr	r3, [r5, #4]
    3854:	2108      	movs	r1, #8
    3856:	4808      	ldr	r0, [pc, #32]	; (3878 <modbus_SlaveProcess+0x164>)
    3858:	e7de      	b.n	3818 <modbus_SlaveProcess+0x104>
		} else
			modbus_SendPacketException(ret);
	} else {
    	// envia uma mensagem de exceção ao mestre que este dispositivo não suporta tal função
    	modbus_SendPacketException(modbusILLEGAL_FUNCTION);
    385a:	2001      	movs	r0, #1
    385c:	f7ff ff22 	bl	36a4 <modbus_SendPacketException>
    }

	modbus.flushRX();
    3860:	6933      	ldr	r3, [r6, #16]
    3862:	4798      	blx	r3
	return pdPASS;
    3864:	2001      	movs	r0, #1
    3866:	e000      	b.n	386a <modbus_SlaveProcess+0x156>
        									// Recomendo fazer uma macro associado ao boudrate da serial
        return pdFAIL;
    }

    // somente vamos processar quando estourar o timeout de recepção
    if (modbus.timeout) return pdFAIL;
    3868:	2000      	movs	r0, #0
    	modbus_SendPacketException(modbusILLEGAL_FUNCTION);
    }

	modbus.flushRX();
	return pdPASS;
}
    386a:	b003      	add	sp, #12
    386c:	bdf0      	pop	{r4, r5, r6, r7, pc}
    386e:	bf00      	nop
    3870:	10000c94 	.word	0x10000c94
    3874:	10000cb3 	.word	0x10000cb3
    3878:	10000cac 	.word	0x10000cac

Disassembly of section .text.modbus_SlaveTick:

0000387c <modbus_SlaveTick>:

//-----------------------------------------------------------------------------------------------------------------------
// Esta função deve ser chamada a cada 1ms
//-----------------------------------------------------------------------------------------------------------------------
void modbus_SlaveTick(void) {
	if (modbus.timeout) modbus.timeout--;
    387c:	4b03      	ldr	r3, [pc, #12]	; (388c <modbus_SlaveTick+0x10>)
    387e:	695a      	ldr	r2, [r3, #20]
    3880:	b112      	cbz	r2, 3888 <modbus_SlaveTick+0xc>
    3882:	695a      	ldr	r2, [r3, #20]
    3884:	3a01      	subs	r2, #1
    3886:	615a      	str	r2, [r3, #20]
    3888:	4770      	bx	lr
    388a:	bf00      	nop
    388c:	10000c94 	.word	0x10000c94

Disassembly of section .text.print_putchar:

00003890 <print_putchar>:
// IMPRESSÃO DE CARACTERES
// #######################################################################################################################

//  Esta função direciona a impressão do caractere para o dipositivo de saida ou armazena em buffer de formatação de string
static void print_putchar(pPrint output, u8 c) {
	if (output->buf!=NULL) { 				// Checa se há buffer para fazer formatação de string
    3890:	6802      	ldr	r2, [r0, #0]
// #######################################################################################################################
// IMPRESSÃO DE CARACTERES
// #######################################################################################################################

//  Esta função direciona a impressão do caractere para o dipositivo de saida ou armazena em buffer de formatação de string
static void print_putchar(pPrint output, u8 c) {
    3892:	b538      	push	{r3, r4, r5, lr}
	if (output->buf!=NULL) { 				// Checa se há buffer para fazer formatação de string
    3894:	b122      	cbz	r2, 38a0 <print_putchar+0x10>
		output->buf[output->count++] = c;
    3896:	6843      	ldr	r3, [r0, #4]
    3898:	1c5c      	adds	r4, r3, #1
    389a:	6044      	str	r4, [r0, #4]
    389c:	54d1      	strb	r1, [r2, r3]
		return;		// se é somente para fazer formatação de string não vamos fazer impressão em dispositivo
    389e:	bd38      	pop	{r3, r4, r5, pc}
	#if defined(LINUX)
	stdio_putc(c);
	#else
	static int (*putcharfunc)(n16 c);
	
	switch(output->device) {
    38a0:	7b03      	ldrb	r3, [r0, #12]
    38a2:	4c10      	ldr	r4, [pc, #64]	; (38e4 <print_putchar+0x54>)
    38a4:	3b01      	subs	r3, #1
    38a6:	2b06      	cmp	r3, #6
    38a8:	d814      	bhi.n	38d4 <print_putchar+0x44>
    38aa:	e8df f003 	tbb	[pc, r3]
    38ae:	0604      	.short	0x0604
    38b0:	0e0c0a08 	.word	0x0e0c0a08
    38b4:	10          	.byte	0x10
    38b5:	00          	.byte	0x00
		case STDIO_LPRINTF:	putcharfunc = stdio_putc; break;
    38b6:	4b0c      	ldr	r3, [pc, #48]	; (38e8 <print_putchar+0x58>)
    38b8:	e00a      	b.n	38d0 <print_putchar+0x40>
		case STDIO_DEBUG:	putcharfunc = debug_putc; break;
    38ba:	4b0c      	ldr	r3, [pc, #48]	; (38ec <print_putchar+0x5c>)
    38bc:	e008      	b.n	38d0 <print_putchar+0x40>
		case STDIO_ERROR:	putcharfunc = err_putc; break;
    38be:	4b0c      	ldr	r3, [pc, #48]	; (38f0 <print_putchar+0x60>)
    38c0:	e006      	b.n	38d0 <print_putchar+0x40>
		case STDIO_DEV1: 	putcharfunc = dev1_putc; break;
    38c2:	4b0c      	ldr	r3, [pc, #48]	; (38f4 <print_putchar+0x64>)
    38c4:	e004      	b.n	38d0 <print_putchar+0x40>
   		case STDIO_DEV2: 	putcharfunc = dev2_putc; break;
    38c6:	4b0c      	ldr	r3, [pc, #48]	; (38f8 <print_putchar+0x68>)
    38c8:	e002      	b.n	38d0 <print_putchar+0x40>
   		case STDIO_DEV3: 	putcharfunc = dev3_putc; break;
    38ca:	4b0c      	ldr	r3, [pc, #48]	; (38fc <print_putchar+0x6c>)
    38cc:	e000      	b.n	38d0 <print_putchar+0x40>
   		case STDIO_DEV4: 	putcharfunc = dev4_putc; break;
    38ce:	4b0c      	ldr	r3, [pc, #48]	; (3900 <print_putchar+0x70>)
    38d0:	681b      	ldr	r3, [r3, #0]
    38d2:	6023      	str	r3, [r4, #0]
  	}

	// senão joga na porta de saida
	// Espera até que consiga incluir o caractere no buffer de TX
	while (putcharfunc(c) < 0) continue;
    38d4:	b20d      	sxth	r5, r1
    38d6:	6823      	ldr	r3, [r4, #0]
    38d8:	4628      	mov	r0, r5
    38da:	4798      	blx	r3
    38dc:	2800      	cmp	r0, #0
    38de:	dbfa      	blt.n	38d6 <print_putchar+0x46>
    38e0:	bd38      	pop	{r3, r4, r5, pc}
    38e2:	bf00      	nop
    38e4:	10000dcc 	.word	0x10000dcc
    38e8:	10000dc8 	.word	0x10000dc8
    38ec:	10000de0 	.word	0x10000de0
    38f0:	10000de4 	.word	0x10000de4
    38f4:	10000dc4 	.word	0x10000dc4
    38f8:	10000dd4 	.word	0x10000dd4
    38fc:	10000dd0 	.word	0x10000dd0
    3900:	10000ddc 	.word	0x10000ddc

Disassembly of section .text.print_fill:

00003904 <print_fill>:
// #######################################################################################################################

//completa a impressao com os caracteres desejados
//n=quantos caracteres ja serao impressos, o que faltar
//a rotina preenche
static void print_fill(pPrint output, int n) {
    3904:	b538      	push	{r3, r4, r5, lr}
    3906:	4605      	mov	r5, r0
    3908:	7a04      	ldrb	r4, [r0, #8]
    390a:	1a64      	subs	r4, r4, r1
	n = output->prefix - n;
	while (n-->0) print_putchar(output, output->fill);
    390c:	2c00      	cmp	r4, #0
    390e:	dd05      	ble.n	391c <print_fill+0x18>
    3910:	7a69      	ldrb	r1, [r5, #9]
    3912:	4628      	mov	r0, r5
    3914:	f7ff ffbc 	bl	3890 <print_putchar>
    3918:	3c01      	subs	r4, #1
    391a:	e7f7      	b.n	390c <print_fill+0x8>
}
    391c:	bd38      	pop	{r3, r4, r5, pc}

Disassembly of section .text.print_int:

0000391e <print_int>:
	while (s[d])
		print_putchar(output, s[d++]);
	print_fill(output, d);
}

static void print_int(pPrint output, int x) {
    391e:	b570      	push	{r4, r5, r6, lr}
    3920:	4605      	mov	r5, r0
	int d,sig;
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
    3922:	2900      	cmp	r1, #0
	while (s[d])
		print_putchar(output, s[d++]);
	print_fill(output, d);
}

static void print_int(pPrint output, int x) {
    3924:	b090      	sub	sp, #64	; 0x40
	int d,sig;
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
    3926:	bfba      	itte	lt
    3928:	4249      	neglt	r1, r1
    392a:	2201      	movlt	r2, #1
    392c:	2200      	movge	r2, #0
	d = 0;
    392e:	2300      	movs	r3, #0
	do	{
		digits[d++] = '0' + x%10;
    3930:	260a      	movs	r6, #10
    3932:	fb91 f0f6 	sdiv	r0, r1, r6
    3936:	fb06 1110 	mls	r1, r6, r0, r1
    393a:	3130      	adds	r1, #48	; 0x30
    393c:	f80d 1003 	strb.w	r1, [sp, r3]
    3940:	1c5c      	adds	r4, r3, #1
		x = x/10;
	}while (x);
    3942:	4601      	mov	r1, r0
    3944:	b108      	cbz	r0, 394a <print_int+0x2c>
	string digits;

	if (x<0) { sig = 1; x = -x; } else sig = 0;
	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    3946:	4623      	mov	r3, r4
    3948:	e7f3      	b.n	3932 <print_int+0x14>
		x = x/10;
	}while (x);
	if (sig) digits[d++] = '-';
    394a:	b12a      	cbz	r2, 3958 <print_int+0x3a>
    394c:	aa10      	add	r2, sp, #64	; 0x40
    394e:	4414      	add	r4, r2
    3950:	222d      	movs	r2, #45	; 0x2d
    3952:	f804 2c40 	strb.w	r2, [r4, #-64]
    3956:	1c9c      	adds	r4, r3, #2

	print_fill(output, d);
    3958:	4621      	mov	r1, r4
    395a:	4628      	mov	r0, r5
    395c:	f7ff ffd2 	bl	3904 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    3960:	f114 34ff 	adds.w	r4, r4, #4294967295
    3964:	d305      	bcc.n	3972 <print_int+0x54>
    3966:	f81d 1004 	ldrb.w	r1, [sp, r4]
    396a:	4628      	mov	r0, r5
    396c:	f7ff ff90 	bl	3890 <print_putchar>
    3970:	e7f6      	b.n	3960 <print_int+0x42>
}
    3972:	b010      	add	sp, #64	; 0x40
    3974:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.print_long:

00003976 <print_long>:

static void print_long(pPrint output, long x) {
    3976:	b570      	push	{r4, r5, r6, lr}
	int d; //digitos
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
    3978:	1e0c      	subs	r4, r1, #0

	print_fill(output, d);
	while (d--) print_putchar(output, digits[d]);
}

static void print_long(pPrint output, long x) {
    397a:	b090      	sub	sp, #64	; 0x40
    397c:	4606      	mov	r6, r0
	int d; //digitos
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
    397e:	da03      	bge.n	3988 <print_long+0x12>
    3980:	212d      	movs	r1, #45	; 0x2d
    3982:	f7ff ff85 	bl	3890 <print_putchar>
    3986:	4264      	negs	r4, r4

	print_fill(output, d);
	while (d--) print_putchar(output, digits[d]);
}

static void print_long(pPrint output, long x) {
    3988:	2500      	movs	r5, #0
	string digits;

	if (x<0) { print_putchar(output,'-'); x = -x; }
	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    398a:	220a      	movs	r2, #10
    398c:	fb94 f3f2 	sdiv	r3, r4, r2
    3990:	fb02 4413 	mls	r4, r2, r3, r4
    3994:	3501      	adds	r5, #1
    3996:	3430      	adds	r4, #48	; 0x30
    3998:	eb0d 0105 	add.w	r1, sp, r5
    399c:	f801 4c01 	strb.w	r4, [r1, #-1]
		x = x/10;
	}while (x);
    39a0:	461c      	mov	r4, r3
    39a2:	2b00      	cmp	r3, #0
    39a4:	d1f2      	bne.n	398c <print_long+0x16>

	print_fill(output, d);
    39a6:	4629      	mov	r1, r5
    39a8:	4630      	mov	r0, r6
    39aa:	f7ff ffab 	bl	3904 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    39ae:	f115 35ff 	adds.w	r5, r5, #4294967295
    39b2:	d305      	bcc.n	39c0 <print_long+0x4a>
    39b4:	f81d 1005 	ldrb.w	r1, [sp, r5]
    39b8:	4630      	mov	r0, r6
    39ba:	f7ff ff69 	bl	3890 <print_putchar>
    39be:	e7f6      	b.n	39ae <print_long+0x38>
}
    39c0:	b010      	add	sp, #64	; 0x40
    39c2:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.print_float:

000039c4 <print_float>:
	print_int(output, s);
}
#endif

#if ( STDIO_USE_FLOAT == pdON )
static void print_float(pPrint output, double x) {
    39c4:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    39c6:	4616      	mov	r6, r2
    39c8:	461d      	mov	r5, r3
    39ca:	4604      	mov	r4, r0
	if (x<0) { print_putchar(output, '-'); x = -x; }
    39cc:	2200      	movs	r2, #0
    39ce:	2300      	movs	r3, #0
    39d0:	4630      	mov	r0, r6
    39d2:	4629      	mov	r1, r5
    39d4:	f7fd f8bc 	bl	b50 <__aeabi_dcmplt>
    39d8:	b128      	cbz	r0, 39e6 <print_float+0x22>
    39da:	212d      	movs	r1, #45	; 0x2d
    39dc:	4620      	mov	r0, r4
    39de:	f7ff ff57 	bl	3890 <print_putchar>
    39e2:	f105 4500 	add.w	r5, r5, #2147483648	; 0x80000000
	//parte inteira
	print_long(output, (long)x);
    39e6:	4629      	mov	r1, r5
    39e8:	4630      	mov	r0, r6
    39ea:	f7fd f8d9 	bl	ba0 <__aeabi_d2iz>
    39ee:	4601      	mov	r1, r0
    39f0:	4607      	mov	r7, r0
    39f2:	4620      	mov	r0, r4
    39f4:	f7ff ffbf 	bl	3976 <print_long>
	if (output->precision<=0) return;
    39f8:	7aa3      	ldrb	r3, [r4, #10]
    39fa:	b3bb      	cbz	r3, 3a6c <print_float+0xa8>
	//parte fracionaria
	print_putchar(output, '.');
    39fc:	212e      	movs	r1, #46	; 0x2e
    39fe:	4620      	mov	r0, r4
    3a00:	f7ff ff46 	bl	3890 <print_putchar>
	output->prefix = 0;
    3a04:	2300      	movs	r3, #0
    3a06:	7223      	strb	r3, [r4, #8]
	x = x - (int)(x);
    3a08:	4638      	mov	r0, r7
    3a0a:	f7fc fdc9 	bl	5a0 <__aeabi_i2d>
    3a0e:	4602      	mov	r2, r0
    3a10:	460b      	mov	r3, r1
    3a12:	4630      	mov	r0, r6
    3a14:	4629      	mov	r1, r5
    3a16:	f7fc fc75 	bl	304 <__aeabi_dsub>
    3a1a:	4606      	mov	r6, r0
    3a1c:	460f      	mov	r7, r1
	while (output->precision-->0) {
    3a1e:	7aa3      	ldrb	r3, [r4, #10]
    3a20:	1e5a      	subs	r2, r3, #1
    3a22:	72a2      	strb	r2, [r4, #10]
		x = x*10.0;
    3a24:	2200      	movs	r2, #0
	if (output->precision<=0) return;
	//parte fracionaria
	print_putchar(output, '.');
	output->prefix = 0;
	x = x - (int)(x);
	while (output->precision-->0) {
    3a26:	b18b      	cbz	r3, 3a4c <print_float+0x88>
		x = x*10.0;
    3a28:	4b11      	ldr	r3, [pc, #68]	; (3a70 <print_float+0xac>)
    3a2a:	4630      	mov	r0, r6
    3a2c:	4639      	mov	r1, r7
    3a2e:	f7fc fe1d 	bl	66c <__aeabi_dmul>
		if (x<1.0) print_putchar(output, '0');
    3a32:	2200      	movs	r2, #0
    3a34:	4b0f      	ldr	r3, [pc, #60]	; (3a74 <print_float+0xb0>)
	//parte fracionaria
	print_putchar(output, '.');
	output->prefix = 0;
	x = x - (int)(x);
	while (output->precision-->0) {
		x = x*10.0;
    3a36:	4606      	mov	r6, r0
    3a38:	460f      	mov	r7, r1
		if (x<1.0) print_putchar(output, '0');
    3a3a:	f7fd f889 	bl	b50 <__aeabi_dcmplt>
    3a3e:	2800      	cmp	r0, #0
    3a40:	d0ed      	beq.n	3a1e <print_float+0x5a>
    3a42:	2130      	movs	r1, #48	; 0x30
    3a44:	4620      	mov	r0, r4
    3a46:	f7ff ff23 	bl	3890 <print_putchar>
    3a4a:	e7e8      	b.n	3a1e <print_float+0x5a>
	}
	if (x>1) print_long(output, (long)x);
    3a4c:	4b09      	ldr	r3, [pc, #36]	; (3a74 <print_float+0xb0>)
    3a4e:	4630      	mov	r0, r6
    3a50:	4639      	mov	r1, r7
    3a52:	f7fd f89b 	bl	b8c <__aeabi_dcmpgt>
    3a56:	b148      	cbz	r0, 3a6c <print_float+0xa8>
    3a58:	4639      	mov	r1, r7
    3a5a:	4630      	mov	r0, r6
    3a5c:	f7fd f8a0 	bl	ba0 <__aeabi_d2iz>
    3a60:	4601      	mov	r1, r0
    3a62:	4620      	mov	r0, r4
}
    3a64:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
	x = x - (int)(x);
	while (output->precision-->0) {
		x = x*10.0;
		if (x<1.0) print_putchar(output, '0');
	}
	if (x>1) print_long(output, (long)x);
    3a68:	f7ff bf85 	b.w	3976 <print_long>
    3a6c:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    3a6e:	bf00      	nop
    3a70:	40240000 	.word	0x40240000
    3a74:	3ff00000 	.word	0x3ff00000

Disassembly of section .text.rprintf_RegisterDev:

00003a78 <rprintf_RegisterDev>:

#if !defined(LINUX)
// Registra a função de saída do determinado dispositivo para usarmos o rprintf
void rprintf_RegisterDev(const u8 device, int(*putc)(n16) ) {
   	// regitrar a função de saida do dispositivo
   	switch(device) {
    3a78:	3804      	subs	r0, #4
    3a7a:	2803      	cmp	r0, #3
    3a7c:	d80b      	bhi.n	3a96 <rprintf_RegisterDev+0x1e>
    3a7e:	e8df f000 	tbb	[pc, r0]
    3a82:	0402      	.short	0x0402
    3a84:	0806      	.short	0x0806
	case STDIO_DEV1: 	dev1_putc = putc; break;
    3a86:	4b04      	ldr	r3, [pc, #16]	; (3a98 <rprintf_RegisterDev+0x20>)
    3a88:	e004      	b.n	3a94 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV2: 	dev2_putc = putc; break;
    3a8a:	4b04      	ldr	r3, [pc, #16]	; (3a9c <rprintf_RegisterDev+0x24>)
    3a8c:	e002      	b.n	3a94 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV3: 	dev3_putc = putc; break;
    3a8e:	4b04      	ldr	r3, [pc, #16]	; (3aa0 <rprintf_RegisterDev+0x28>)
    3a90:	e000      	b.n	3a94 <rprintf_RegisterDev+0x1c>
   	case STDIO_DEV4: 	dev4_putc = putc; break;
    3a92:	4b04      	ldr	r3, [pc, #16]	; (3aa4 <rprintf_RegisterDev+0x2c>)
    3a94:	6019      	str	r1, [r3, #0]
    3a96:	4770      	bx	lr
    3a98:	10000dc4 	.word	0x10000dc4
    3a9c:	10000dd4 	.word	0x10000dd4
    3aa0:	10000dd0 	.word	0x10000dd0
    3aa4:	10000ddc 	.word	0x10000ddc

Disassembly of section .text.lputchar_RegisterDev:

00003aa8 <lputchar_RegisterDev>:
}
#endif // #if !defined(LINUX)

// Registra a função de saída padrão
void lputchar_RegisterDev(int (*func_putc)(n16)) {
	stdio_putc = func_putc;
    3aa8:	4b01      	ldr	r3, [pc, #4]	; (3ab0 <lputchar_RegisterDev+0x8>)
    3aaa:	6018      	str	r0, [r3, #0]
    3aac:	4770      	bx	lr
    3aae:	bf00      	nop
    3ab0:	10000dc8 	.word	0x10000dc8

Disassembly of section .text.ldebug_RegisterDev:

00003ab4 <ldebug_RegisterDev>:
}

// Registra a função de saída padrão de LOG
void ldebug_RegisterDev(int (*putc)(n16)) {
	debug_putc = putc;
    3ab4:	4b01      	ldr	r3, [pc, #4]	; (3abc <ldebug_RegisterDev+0x8>)
    3ab6:	6018      	str	r0, [r3, #0]
    3ab8:	4770      	bx	lr
    3aba:	bf00      	nop
    3abc:	10000de0 	.word	0x10000de0

Disassembly of section .text.lgetchar_RegisterDev:

00003ac0 <lgetchar_RegisterDev>:
#endif // #if defined(FREE_RTOS)


// Registra a função de entrada padrão
void lgetchar_RegisterDev(int (*func_getc)(u8*)) {
	stdio_getc = func_getc;
    3ac0:	4b01      	ldr	r3, [pc, #4]	; (3ac8 <lgetchar_RegisterDev+0x8>)
    3ac2:	6018      	str	r0, [r3, #0]
    3ac4:	4770      	bx	lr
    3ac6:	bf00      	nop
    3ac8:	10000dd8 	.word	0x10000dd8

Disassembly of section .text.doprint:

00003acc <doprint>:
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    3acc:	e92d 43f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, lr}
    3ad0:	4604      	mov	r4, r0
    3ad2:	4615      	mov	r5, r2
    3ad4:	4688      	mov	r8, r1
	char c, doformat = 0;

	output->count = 0;
    3ad6:	2100      	movs	r1, #0
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    3ad8:	b095      	sub	sp, #84	; 0x54
	char c, doformat = 0;

	output->count = 0;
    3ada:	6041      	str	r1, [r0, #4]

	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;
    3adc:	f108 0701 	add.w	r7, r8, #1
    3ae0:	f898 6000 	ldrb.w	r6, [r8]

		if (doformat) {
    3ae4:	2900      	cmp	r1, #0
    3ae6:	f000 818b 	beq.w	3e00 <doprint+0x334>
			doformat = 0;

			if ( ((c=='l')||(c=='L')) &&(*fmt=='d')) {
    3aea:	f006 03df 	and.w	r3, r6, #223	; 0xdf
    3aee:	2b4c      	cmp	r3, #76	; 0x4c
    3af0:	d10b      	bne.n	3b0a <doprint+0x3e>
    3af2:	f898 3001 	ldrb.w	r3, [r8, #1]
    3af6:	2b64      	cmp	r3, #100	; 0x64
    3af8:	d107      	bne.n	3b0a <doprint+0x3e>
				print_long(output, va_arg(args,long));
    3afa:	6829      	ldr	r1, [r5, #0]
    3afc:	4620      	mov	r0, r4
    3afe:	1d2e      	adds	r6, r5, #4
    3b00:	f7ff ff39 	bl	3976 <print_long>
				fmt++;
    3b04:	f108 0702 	add.w	r7, r8, #2
    3b08:	e0bd      	b.n	3c86 <doprint+0x1ba>
				continue;
			}

			switch (c) {
    3b0a:	2e63      	cmp	r6, #99	; 0x63
    3b0c:	d03c      	beq.n	3b88 <doprint+0xbc>
    3b0e:	d819      	bhi.n	3b44 <doprint+0x78>
    3b10:	2e53      	cmp	r6, #83	; 0x53
    3b12:	f000 808c 	beq.w	3c2e <doprint+0x162>
    3b16:	d80c      	bhi.n	3b32 <doprint+0x66>
    3b18:	2e43      	cmp	r6, #67	; 0x43
    3b1a:	d035      	beq.n	3b88 <doprint+0xbc>
    3b1c:	2e44      	cmp	r6, #68	; 0x44
    3b1e:	d036      	beq.n	3b8e <doprint+0xc2>
    3b20:	2e25      	cmp	r6, #37	; 0x25
    3b22:	f040 814f 	bne.w	3dc4 <doprint+0x2f8>
			case '%' : print_putchar(output, '%'); break;
    3b26:	4631      	mov	r1, r6
    3b28:	4620      	mov	r0, r4
    3b2a:	f7ff feb1 	bl	3890 <print_putchar>
    3b2e:	462e      	mov	r6, r5
    3b30:	e17b      	b.n	3e2a <doprint+0x35e>
				print_long(output, va_arg(args,long));
				fmt++;
				continue;
			}

			switch (c) {
    3b32:	2e58      	cmp	r6, #88	; 0x58
    3b34:	d04f      	beq.n	3bd6 <doprint+0x10a>
    3b36:	2e62      	cmp	r6, #98	; 0x62
    3b38:	f000 80d4 	beq.w	3ce4 <doprint+0x218>
    3b3c:	2e55      	cmp	r6, #85	; 0x55
    3b3e:	f040 8141 	bne.w	3dc4 <doprint+0x2f8>
    3b42:	e027      	b.n	3b94 <doprint+0xc8>
    3b44:	2e6b      	cmp	r6, #107	; 0x6b
    3b46:	f000 8088 	beq.w	3c5a <doprint+0x18e>
    3b4a:	d811      	bhi.n	3b70 <doprint+0xa4>
    3b4c:	2e65      	cmp	r6, #101	; 0x65
    3b4e:	f000 80e8 	beq.w	3d22 <doprint+0x256>
    3b52:	d31c      	bcc.n	3b8e <doprint+0xc2>
    3b54:	2e66      	cmp	r6, #102	; 0x66
    3b56:	f040 8135 	bne.w	3dc4 <doprint+0x2f8>
			#endif
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_FLOAT == pdON )
			case 'f' : print_float(output, va_arg(args, double)); break;
    3b5a:	3507      	adds	r5, #7
    3b5c:	f025 0507 	bic.w	r5, r5, #7
    3b60:	e9d5 2300 	ldrd	r2, r3, [r5]
    3b64:	4620      	mov	r0, r4
    3b66:	f105 0608 	add.w	r6, r5, #8
    3b6a:	f7ff ff2b 	bl	39c4 <print_float>
    3b6e:	e15c      	b.n	3e2a <doprint+0x35e>
				print_long(output, va_arg(args,long));
				fmt++;
				continue;
			}

			switch (c) {
    3b70:	2e74      	cmp	r6, #116	; 0x74
    3b72:	f000 8094 	beq.w	3c9e <doprint+0x1d2>
    3b76:	d802      	bhi.n	3b7e <doprint+0xb2>
    3b78:	2e73      	cmp	r6, #115	; 0x73
    3b7a:	d058      	beq.n	3c2e <doprint+0x162>
    3b7c:	e122      	b.n	3dc4 <doprint+0x2f8>
    3b7e:	2e75      	cmp	r6, #117	; 0x75
    3b80:	d008      	beq.n	3b94 <doprint+0xc8>
    3b82:	2e78      	cmp	r6, #120	; 0x78
    3b84:	d027      	beq.n	3bd6 <doprint+0x10a>
    3b86:	e11d      	b.n	3dc4 <doprint+0x2f8>
			case '%' : print_putchar(output, '%'); break;
			case 'C' :
			case 'c' : print_putchar(output, va_arg(args,int)); break;
    3b88:	1d2e      	adds	r6, r5, #4
    3b8a:	7829      	ldrb	r1, [r5, #0]
    3b8c:	e083      	b.n	3c96 <doprint+0x1ca>
			case 'D' :
			case 'd' : print_int(output, va_arg(args,int)); break;
    3b8e:	1d2e      	adds	r6, r5, #4
    3b90:	6829      	ldr	r1, [r5, #0]
    3b92:	e113      	b.n	3dbc <doprint+0x2f0>
			case 'U' :
			case 'u' : print_uint(output, va_arg(args,int)); break;
    3b94:	1d2e      	adds	r6, r5, #4
    3b96:	682b      	ldr	r3, [r5, #0]
	unsigned int d; //digitos
	string digits;

	d = 0;
	do	{
		digits[d++] = '0' + x%10;
    3b98:	f10d 0810 	add.w	r8, sp, #16

static void print_uint(pPrint output, unsigned int x) {
	unsigned int d; //digitos
	string digits;

	d = 0;
    3b9c:	2500      	movs	r5, #0
	do	{
		digits[d++] = '0' + x%10;
    3b9e:	210a      	movs	r1, #10
    3ba0:	fbb3 f2f1 	udiv	r2, r3, r1
    3ba4:	fb01 3312 	mls	r3, r1, r2, r3
    3ba8:	3501      	adds	r5, #1
    3baa:	3330      	adds	r3, #48	; 0x30
    3bac:	eb08 0005 	add.w	r0, r8, r5
    3bb0:	f800 3c01 	strb.w	r3, [r0, #-1]
		x = x/10;
	}while (x);
    3bb4:	4613      	mov	r3, r2
    3bb6:	2a00      	cmp	r2, #0
    3bb8:	d1f2      	bne.n	3ba0 <doprint+0xd4>

	print_fill(output, d);
    3bba:	4629      	mov	r1, r5
    3bbc:	4620      	mov	r0, r4
    3bbe:	f7ff fea1 	bl	3904 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    3bc2:	f115 35ff 	adds.w	r5, r5, #4294967295
    3bc6:	f0c0 8130 	bcc.w	3e2a <doprint+0x35e>
    3bca:	f818 1005 	ldrb.w	r1, [r8, r5]
    3bce:	4620      	mov	r0, r4
    3bd0:	f7ff fe5e 	bl	3890 <print_putchar>
    3bd4:	e7f5      	b.n	3bc2 <doprint+0xf6>
}
#endif

#if ( STDIO_USE_HEX == pdON )
static void print_hex(pPrint output, unsigned int x) {
	const char HexTable[16] = {
    3bd6:	46ee      	mov	lr, sp
    3bd8:	4b97      	ldr	r3, [pc, #604]	; (3e38 <doprint+0x36c>)
			case 'd' : print_int(output, va_arg(args,int)); break;
			case 'U' :
			case 'u' : print_uint(output, va_arg(args,int)); break;
			#if ( STDIO_USE_HEX == pdON )
			case 'X' :
			case 'x' : print_hex(output, va_arg(args,int));	break;
    3bda:	682a      	ldr	r2, [r5, #0]
    3bdc:	1d2e      	adds	r6, r5, #4
}
#endif

#if ( STDIO_USE_HEX == pdON )
static void print_hex(pPrint output, unsigned int x) {
	const char HexTable[16] = {
    3bde:	f103 0c10 	add.w	ip, r3, #16
    3be2:	4675      	mov	r5, lr
    3be4:	6818      	ldr	r0, [r3, #0]
    3be6:	6859      	ldr	r1, [r3, #4]
    3be8:	3308      	adds	r3, #8
    3bea:	c503      	stmia	r5!, {r0, r1}
    3bec:	4563      	cmp	r3, ip
    3bee:	46ae      	mov	lr, r5
    3bf0:	d1f7      	bne.n	3be2 <doprint+0x116>
		'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
	};
	char digits[16];

	int d = 0;
    3bf2:	2500      	movs	r5, #0
	do	{
		digits[d++] = HexTable[x&0xF];
    3bf4:	f10d 0810 	add.w	r8, sp, #16
    3bf8:	f002 030f 	and.w	r3, r2, #15
    3bfc:	a814      	add	r0, sp, #80	; 0x50
    3bfe:	4403      	add	r3, r0
    3c00:	3501      	adds	r5, #1
    3c02:	f813 3c50 	ldrb.w	r3, [r3, #-80]
    3c06:	eb08 0105 	add.w	r1, r8, r5
		x = x>>4;
	}while (x);
    3c0a:	0912      	lsrs	r2, r2, #4
	};
	char digits[16];

	int d = 0;
	do	{
		digits[d++] = HexTable[x&0xF];
    3c0c:	f801 3c01 	strb.w	r3, [r1, #-1]
		x = x>>4;
	}while (x);
    3c10:	d1f2      	bne.n	3bf8 <doprint+0x12c>

	//print_putchar(output, '0');
	//print_putchar(output, 'x');
	print_fill(output, d);
    3c12:	4629      	mov	r1, r5
    3c14:	4620      	mov	r0, r4
    3c16:	f7ff fe75 	bl	3904 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    3c1a:	f115 35ff 	adds.w	r5, r5, #4294967295
    3c1e:	f0c0 8104 	bcc.w	3e2a <doprint+0x35e>
    3c22:	f818 1005 	ldrb.w	r1, [r8, r5]
    3c26:	4620      	mov	r0, r4
    3c28:	f7ff fe32 	bl	3890 <print_putchar>
    3c2c:	e7f5      	b.n	3c1a <doprint+0x14e>
			#if ( STDIO_USE_HEX == pdON )
			case 'X' :
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
    3c2e:	1d2e      	adds	r6, r5, #4
    3c30:	682d      	ldr	r5, [r5, #0]
	while (n-->0) print_putchar(output, output->fill);
}

static void print_string(pPrint output, char * s) {
	int d = 0;
	if (s==NULL) return;
    3c32:	2d00      	cmp	r5, #0
    3c34:	f000 80f9 	beq.w	3e2a <doprint+0x35e>
    3c38:	46a9      	mov	r9, r5
    3c3a:	ebc5 0109 	rsb	r1, r5, r9
	while (s[d])
    3c3e:	f819 8b01 	ldrb.w	r8, [r9], #1
    3c42:	f1b8 0f00 	cmp.w	r8, #0
    3c46:	d004      	beq.n	3c52 <doprint+0x186>
		print_putchar(output, s[d++]);
    3c48:	4641      	mov	r1, r8
    3c4a:	4620      	mov	r0, r4
    3c4c:	f7ff fe20 	bl	3890 <print_putchar>
    3c50:	e7f3      	b.n	3c3a <doprint+0x16e>
	print_fill(output, d);
    3c52:	4620      	mov	r0, r4
    3c54:	f7ff fe56 	bl	3904 <print_fill>
    3c58:	e0e7      	b.n	3e2a <doprint+0x35e>
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
    3c5a:	1d2e      	adds	r6, r5, #4
    3c5c:	6829      	ldr	r1, [r5, #0]
	while (d--) print_putchar(output, digits[d]);
}

#if ( STDIO_USE_SUBINT == pdON )
static void print_intF(pPrint output, long x) {
	int b = 0;
    3c5e:	2500      	movs	r5, #0
	while (x>10240) { x = x/1024; b++; }
    3c60:	f5b1 5f20 	cmp.w	r1, #10240	; 0x2800
    3c64:	dd02      	ble.n	3c6c <doprint+0x1a0>
    3c66:	1289      	asrs	r1, r1, #10
    3c68:	3501      	adds	r5, #1
    3c6a:	e7f9      	b.n	3c60 <doprint+0x194>
	print_int(output, x);
    3c6c:	4620      	mov	r0, r4
    3c6e:	f7ff fe56 	bl	391e <print_int>
	if (b==1) print_putchar(output, 'k');
    3c72:	2d01      	cmp	r5, #1
    3c74:	d101      	bne.n	3c7a <doprint+0x1ae>
    3c76:	216b      	movs	r1, #107	; 0x6b
    3c78:	e00d      	b.n	3c96 <doprint+0x1ca>
	if (b==2) print_putchar(output, 'M');
    3c7a:	2d02      	cmp	r5, #2
    3c7c:	d107      	bne.n	3c8e <doprint+0x1c2>
    3c7e:	214d      	movs	r1, #77	; 0x4d
    3c80:	4620      	mov	r0, r4
    3c82:	f7ff fe05 	bl	3890 <print_putchar>
			case 'x' : print_hex(output, va_arg(args,int));	break;
			#endif
			case 'S' :
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
    3c86:	4635      	mov	r5, r6
    3c88:	2100      	movs	r1, #0
	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;

		if (doformat) {
			doformat = 0;
    3c8a:	46b8      	mov	r8, r7
    3c8c:	e726      	b.n	3adc <doprint+0x10>
	int b = 0;
	while (x>10240) { x = x/1024; b++; }
	print_int(output, x);
	if (b==1) print_putchar(output, 'k');
	if (b==2) print_putchar(output, 'M');
	if (b==3) print_putchar(output, 'G');
    3c8e:	2d03      	cmp	r5, #3
    3c90:	f040 80cb 	bne.w	3e2a <doprint+0x35e>
    3c94:	2147      	movs	r1, #71	; 0x47
    3c96:	4620      	mov	r0, r4
    3c98:	f7ff fdfa 	bl	3890 <print_putchar>
    3c9c:	e0c5      	b.n	3e2a <doprint+0x35e>
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
    3c9e:	f8d5 9000 	ldr.w	r9, [r5]
	s = x%60;	x = x/60;
	m = x%60;	x = x/60;
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
    3ca2:	2302      	movs	r3, #2
    3ca4:	7223      	strb	r3, [r4, #8]
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    3ca6:	f44f 6161 	mov.w	r1, #3600	; 0xe10
	m = x%60;	x = x/60;
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
    3caa:	2330      	movs	r3, #48	; 0x30
    3cac:	7263      	strb	r3, [r4, #9]
	print_int(output, h);	print_putchar(output, ':');
    3cae:	fb99 f1f1 	sdiv	r1, r9, r1
    3cb2:	4620      	mov	r0, r4
    3cb4:	f7ff fe33 	bl	391e <print_int>
			case 's' : print_string(output, (char*)va_arg(args,int)); break;
			#if ( STDIO_USE_SUBINT == pdON )
			case 'k' : print_intF(output, va_arg(args,long));	break;
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
    3cb8:	1d2e      	adds	r6, r5, #4
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    3cba:	213a      	movs	r1, #58	; 0x3a
	print_int(output, m);	print_putchar(output, 39);
    3cbc:	253c      	movs	r5, #60	; 0x3c
	h = x;

	//formato = "00:00'00"
	output->prefix = 2;
	output->fill = '0';
	print_int(output, h);	print_putchar(output, ':');
    3cbe:	4620      	mov	r0, r4
    3cc0:	f7ff fde6 	bl	3890 <print_putchar>
	print_int(output, m);	print_putchar(output, 39);
    3cc4:	fb99 f8f5 	sdiv	r8, r9, r5
    3cc8:	fb98 f1f5 	sdiv	r1, r8, r5
    3ccc:	4620      	mov	r0, r4
    3cce:	fb05 8111 	mls	r1, r5, r1, r8
    3cd2:	f7ff fe24 	bl	391e <print_int>
    3cd6:	2127      	movs	r1, #39	; 0x27
    3cd8:	4620      	mov	r0, r4
    3cda:	f7ff fdd9 	bl	3890 <print_putchar>
	print_int(output, s);
    3cde:	fb05 9118 	mls	r1, r5, r8, r9
    3ce2:	e06b      	b.n	3dbc <doprint+0x2f0>

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
    3ce4:	2230      	movs	r2, #48	; 0x30
			#endif
			#if ( STDIO_USE_TIME == pdON )
			case 't' : print_time(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
    3ce6:	682b      	ldr	r3, [r5, #0]
    3ce8:	1d2e      	adds	r6, r5, #4

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
    3cea:	7262      	strb	r2, [r4, #9]
#endif

#if ( STDIO_USE_BIN == pdON )
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
    3cec:	2500      	movs	r5, #0
	output->fill = '0';
	do {
		digits[d++] = '0'+(x&1);
    3cee:	f10d 0810 	add.w	r8, sp, #16
    3cf2:	f003 0201 	and.w	r2, r3, #1
    3cf6:	3501      	adds	r5, #1
    3cf8:	eb08 0105 	add.w	r1, r8, r5
    3cfc:	3230      	adds	r2, #48	; 0x30
		x = x>>1;
	}while (x);
    3cfe:	105b      	asrs	r3, r3, #1
static void print_bin(pPrint output, long x) {
	string digits;
	int d = 0;
	output->fill = '0';
	do {
		digits[d++] = '0'+(x&1);
    3d00:	f801 2c01 	strb.w	r2, [r1, #-1]
		x = x>>1;
	}while (x);
    3d04:	d1f5      	bne.n	3cf2 <doprint+0x226>
	//print_putchar(output, '0');
	//print_putchar(output, 'b');
	print_fill(output, d);
    3d06:	4629      	mov	r1, r5
    3d08:	4620      	mov	r0, r4
    3d0a:	f7ff fdfb 	bl	3904 <print_fill>
	while (d--) print_putchar(output, digits[d]);
    3d0e:	f115 35ff 	adds.w	r5, r5, #4294967295
    3d12:	f0c0 808a 	bcc.w	3e2a <doprint+0x35e>
    3d16:	f818 1005 	ldrb.w	r1, [r8, r5]
    3d1a:	4620      	mov	r0, r4
    3d1c:	f7ff fdb8 	bl	3890 <print_putchar>
    3d20:	e7f5      	b.n	3d0e <doprint+0x242>
			#if ( STDIO_USE_BIN == pdON )
			case 'b' : print_bin(output, va_arg(args,long)); break;
			#endif
			#if ( STDIO_USE_FLOAT == pdON )
			case 'f' : print_float(output, va_arg(args, double)); break;
			case 'e' : print_exp(output, va_arg(args, double)); break;
    3d22:	3507      	adds	r5, #7
    3d24:	f025 0507 	bic.w	r5, r5, #7
    3d28:	f8d5 8000 	ldr.w	r8, [r5]
    3d2c:	f105 0608 	add.w	r6, r5, #8
    3d30:	686d      	ldr	r5, [r5, #4]
	if (x>1) print_long(output, (long)x);
}

static void print_exp(pPrint output, double x) {
	int exp = 0;
	if (x<0) { print_putchar(output, '-'); x = -x; }
    3d32:	2200      	movs	r2, #0
    3d34:	2300      	movs	r3, #0
    3d36:	4640      	mov	r0, r8
    3d38:	4629      	mov	r1, r5
    3d3a:	f7fc ff09 	bl	b50 <__aeabi_dcmplt>
    3d3e:	b128      	cbz	r0, 3d4c <doprint+0x280>
    3d40:	212d      	movs	r1, #45	; 0x2d
    3d42:	4620      	mov	r0, r4
    3d44:	f7ff fda4 	bl	3890 <print_putchar>
    3d48:	f105 4500 	add.w	r5, r5, #2147483648	; 0x80000000
	if (x!=0) {
    3d4c:	2200      	movs	r2, #0
    3d4e:	2300      	movs	r3, #0
    3d50:	4640      	mov	r0, r8
    3d52:	4629      	mov	r1, r5
    3d54:	f7fc fef2 	bl	b3c <__aeabi_dcmpeq>
    3d58:	bb20      	cbnz	r0, 3da4 <doprint+0x2d8>
    3d5a:	4681      	mov	r9, r0
		while (x<1) { x = x*10; exp--; }
    3d5c:	2200      	movs	r2, #0
    3d5e:	4b37      	ldr	r3, [pc, #220]	; (3e3c <doprint+0x370>)
    3d60:	4640      	mov	r0, r8
    3d62:	4629      	mov	r1, r5
    3d64:	f7fc fef4 	bl	b50 <__aeabi_dcmplt>
    3d68:	b150      	cbz	r0, 3d80 <doprint+0x2b4>
    3d6a:	4640      	mov	r0, r8
    3d6c:	4629      	mov	r1, r5
    3d6e:	2200      	movs	r2, #0
    3d70:	4b33      	ldr	r3, [pc, #204]	; (3e40 <doprint+0x374>)
    3d72:	f7fc fc7b 	bl	66c <__aeabi_dmul>
    3d76:	f109 39ff 	add.w	r9, r9, #4294967295
    3d7a:	4680      	mov	r8, r0
    3d7c:	460d      	mov	r5, r1
    3d7e:	e7ed      	b.n	3d5c <doprint+0x290>
		while (x>10){ x = x/10; exp++; }
    3d80:	2200      	movs	r2, #0
    3d82:	4b2f      	ldr	r3, [pc, #188]	; (3e40 <doprint+0x374>)
    3d84:	4640      	mov	r0, r8
    3d86:	4629      	mov	r1, r5
    3d88:	f7fc ff00 	bl	b8c <__aeabi_dcmpgt>
    3d8c:	b160      	cbz	r0, 3da8 <doprint+0x2dc>
    3d8e:	4640      	mov	r0, r8
    3d90:	4629      	mov	r1, r5
    3d92:	2200      	movs	r2, #0
    3d94:	4b2a      	ldr	r3, [pc, #168]	; (3e40 <doprint+0x374>)
    3d96:	f7fc fd93 	bl	8c0 <__aeabi_ddiv>
    3d9a:	f109 0901 	add.w	r9, r9, #1
    3d9e:	4680      	mov	r8, r0
    3da0:	460d      	mov	r5, r1
    3da2:	e7ed      	b.n	3d80 <doprint+0x2b4>
	}
	if (x>1) print_long(output, (long)x);
}

static void print_exp(pPrint output, double x) {
	int exp = 0;
    3da4:	f04f 0900 	mov.w	r9, #0
	if (x<0) { print_putchar(output, '-'); x = -x; }
	if (x!=0) {
		while (x<1) { x = x*10; exp--; }
		while (x>10){ x = x/10; exp++; }
	}
	print_float(output, x);
    3da8:	4642      	mov	r2, r8
    3daa:	462b      	mov	r3, r5
    3dac:	4620      	mov	r0, r4
    3dae:	f7ff fe09 	bl	39c4 <print_float>
	print_putchar(output, 'E');
    3db2:	2145      	movs	r1, #69	; 0x45
    3db4:	4620      	mov	r0, r4
    3db6:	f7ff fd6b 	bl	3890 <print_putchar>
	print_int(output, exp);
    3dba:	4649      	mov	r1, r9
    3dbc:	4620      	mov	r0, r4
    3dbe:	f7ff fdae 	bl	391e <print_int>
    3dc2:	e032      	b.n	3e2a <doprint+0x35e>
			case 'f' : print_float(output, va_arg(args, double)); break;
			case 'e' : print_exp(output, va_arg(args, double)); break;
			#endif
			default :
				// preencher com '0'?
				if ( (c=='0')&&(output->prefix==0) ) {
    3dc4:	2e30      	cmp	r6, #48	; 0x30
    3dc6:	d103      	bne.n	3dd0 <doprint+0x304>
    3dc8:	7a23      	ldrb	r3, [r4, #8]
    3dca:	b953      	cbnz	r3, 3de2 <doprint+0x316>
					doformat = 1; output->fill = '0';
    3dcc:	7266      	strb	r6, [r4, #9]
    3dce:	e01e      	b.n	3e0e <doprint+0x342>
					continue;
				}

				// vai indicar a precisao
				if (c=='.') {
    3dd0:	2e2e      	cmp	r6, #46	; 0x2e
    3dd2:	d106      	bne.n	3de2 <doprint+0x316>
					doformat = 1;
					output->precision = (*fmt++)-'0';
    3dd4:	f898 3001 	ldrb.w	r3, [r8, #1]
    3dd8:	f108 0702 	add.w	r7, r8, #2
    3ddc:	3b30      	subs	r3, #48	; 0x30
    3dde:	72a3      	strb	r3, [r4, #10]
    3de0:	e015      	b.n	3e0e <doprint+0x342>
					continue;
				}

				//esta indicando o prefixo...
				if ( (c>='0')&&(c<='9') ) {
    3de2:	f1a6 0330 	sub.w	r3, r6, #48	; 0x30
    3de6:	2b09      	cmp	r3, #9
    3de8:	d808      	bhi.n	3dfc <doprint+0x330>
					doformat = 1;
					output->prefix = output->prefix*10 + (c - '0');
    3dea:	7a23      	ldrb	r3, [r4, #8]
					continue;
				}

				//esta indicando o prefixo...
				if ( (c>='0')&&(c<='9') ) {
					doformat = 1;
    3dec:	2101      	movs	r1, #1
					output->prefix = output->prefix*10 + (c - '0');
    3dee:	eb03 0383 	add.w	r3, r3, r3, lsl #2
    3df2:	eb06 0643 	add.w	r6, r6, r3, lsl #1
    3df6:	3e30      	subs	r6, #48	; 0x30
    3df8:	7226      	strb	r6, [r4, #8]
					continue;
    3dfa:	e746      	b.n	3c8a <doprint+0x1be>
				}
				print_putchar(output, '?');
    3dfc:	213f      	movs	r1, #63	; 0x3f
    3dfe:	e00d      	b.n	3e1c <doprint+0x350>
				break;
			}
			continue;
		}

		if (c=='%')	{
    3e00:	2e25      	cmp	r6, #37	; 0x25
    3e02:	d107      	bne.n	3e14 <doprint+0x348>
			doformat = 1;
			output->prefix = 0;
			output->precision = 5;
    3e04:	2305      	movs	r3, #5
    3e06:	72a3      	strb	r3, [r4, #10]
			output->fill = ' ';
    3e08:	2320      	movs	r3, #32
			continue;
		}

		if (c=='%')	{
			doformat = 1;
			output->prefix = 0;
    3e0a:	7221      	strb	r1, [r4, #8]
			output->precision = 5;
			output->fill = ' ';
    3e0c:	7263      	strb	r3, [r4, #9]
			continue;
    3e0e:	462e      	mov	r6, r5
			}
			continue;
		}

		if (c=='%')	{
			doformat = 1;
    3e10:	2101      	movs	r1, #1
			output->prefix = 0;
			output->precision = 5;
			output->fill = ' ';
			continue;
    3e12:	e00b      	b.n	3e2c <doprint+0x360>
		}

		// Não imprime o caractere nulo (foi incluso essa cláusula em 27/06/2014)
		// o caractere nulo somente será impresso caso for chamado sformat (foi incluso essa cláusula em 14/07/2014)
		//	Pois é preciso adicionar o finalizador de string
		if ( (c > 0) || ((c==0) && (output->isSformat)))
    3e14:	b90e      	cbnz	r6, 3e1a <doprint+0x34e>
    3e16:	7ae3      	ldrb	r3, [r4, #11]
    3e18:	b153      	cbz	r3, 3e30 <doprint+0x364>
			print_putchar(output, c);
    3e1a:	4631      	mov	r1, r6
    3e1c:	4620      	mov	r0, r4
    3e1e:	f7ff fd37 	bl	3890 <print_putchar>
	} while (c);
    3e22:	2e00      	cmp	r6, #0
    3e24:	f47f af30 	bne.w	3c88 <doprint+0x1bc>
    3e28:	e002      	b.n	3e30 <doprint+0x364>
	//repete o processo ate encontrar o terminador nulo
	do {
		c = *fmt++;

		if (doformat) {
			doformat = 0;
    3e2a:	2100      	movs	r1, #0
	print_putchar(output, 'E');
	print_int(output, exp);
}
#endif

void doprint(pPrint output, cpchar fmt, va_list args) {
    3e2c:	4635      	mov	r5, r6
    3e2e:	e72c      	b.n	3c8a <doprint+0x1be>
		// o caractere nulo somente será impresso caso for chamado sformat (foi incluso essa cláusula em 14/07/2014)
		//	Pois é preciso adicionar o finalizador de string
		if ( (c > 0) || ((c==0) && (output->isSformat)))
			print_putchar(output, c);
	} while (c);
}
    3e30:	b015      	add	sp, #84	; 0x54
    3e32:	e8bd 83f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, pc}
    3e36:	bf00      	nop
    3e38:	00004b2c 	.word	0x00004b2c
    3e3c:	3ff00000 	.word	0x3ff00000
    3e40:	40240000 	.word	0x40240000

Disassembly of section .text.lgetchar:

00003e44 <lgetchar>:

// #######################################################################################################################
// FUNÇÕES DE ENTRADA E DE SAÍDAS DE IMPRESSÃO NOS DISPOSITIVOS
// #######################################################################################################################
int lgetchar(u8 *ch) {
	return stdio_getc(ch);
    3e44:	4b01      	ldr	r3, [pc, #4]	; (3e4c <lgetchar+0x8>)
    3e46:	681b      	ldr	r3, [r3, #0]
    3e48:	4718      	bx	r3
    3e4a:	bf00      	nop
    3e4c:	10000dd8 	.word	0x10000dd8

Disassembly of section .text.rprintf:

00003e50 <rprintf>:
//	lprintf("BIN: 0b%b 0b%2b"CMD_TERMINATOR, 0x123, 0x456);
//	lprintf("String: %s"CMD_TERMINATOR, "imprimindo");
#if defined(LINUX)
int rprintf(const char* fmt, ...) {
#else
int rprintf(const u8 device, const cpchar fmt, ...) {
    3e50:	b40e      	push	{r1, r2, r3}
    3e52:	b53f      	push	{r0, r1, r2, r3, r4, r5, lr}
    3e54:	aa07      	add	r2, sp, #28
    3e56:	f852 1b04 	ldr.w	r1, [r2], #4
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
	#endif
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
    3e5a:	2300      	movs	r3, #0
	// Travar o recurso de saída para transmissão completa da mensagem, esperar MAX_DELAY caso o recurso está sendo usado
	ret = xSemaphoreTake(mutex, portMAX_DELAY);
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
    3e5c:	f88d 0014 	strb.w	r0, [sp, #20]
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
	output.isSformat = 0;			// Sinaliza que não é um sformat

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    3e60:	a802      	add	r0, sp, #8
	#endif

	#if !defined(LINUX)
	output.device = device;			// Sinaliza qual dipositivo de saída deve ser impresso
	#endif
	output.buf = NULL;				// Sinaliza que não vamos usar buffer para formatação de string
    3e62:	9302      	str	r3, [sp, #8]
	output.isSformat = 0;			// Sinaliza que não é um sformat
    3e64:	f88d 3013 	strb.w	r3, [sp, #19]

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
    3e68:	9201      	str	r2, [sp, #4]
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    3e6a:	f7ff fe2f 	bl	3acc <doprint>
	// Liberar o recuro de saida
	xSemaphoreGive(mutex);
	#endif

  	return ret;
}
    3e6e:	2001      	movs	r0, #1
    3e70:	b006      	add	sp, #24
    3e72:	f85d eb04 	ldr.w	lr, [sp], #4
    3e76:	b003      	add	sp, #12
    3e78:	4770      	bx	lr

Disassembly of section .text.sformat:

00003e7a <sformat>:
//	sformat(s, "HEX: 0x%x 0x%2x", 0x123, 0x456);
//	sformat(s, "BIN: 0b%b 0b%2b", 0x123, 0x456);
//	sformat(s, "String: %s", "imprimindo");

// sformat(s,"%02d:%02d", rtc->hour, rtc->min); //convertendo hora
void sformat(pchar s, cpchar fmt, ...) {
    3e7a:	b40e      	push	{r1, r2, r3}
    3e7c:	b53f      	push	{r0, r1, r2, r3, r4, r5, lr}
    3e7e:	aa07      	add	r2, sp, #28
    3e80:	f852 1b04 	ldr.w	r1, [r2], #4
	tPrint output;

	output.device = 0;
    3e84:	2300      	movs	r3, #0
    3e86:	f88d 3014 	strb.w	r3, [sp, #20]
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
    3e8a:	9002      	str	r0, [sp, #8]
	output.isSformat = 1;			// Sinaliza que é um sformat
    3e8c:	2301      	movs	r3, #1

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    3e8e:	a802      	add	r0, sp, #8
void sformat(pchar s, cpchar fmt, ...) {
	tPrint output;

	output.device = 0;
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
	output.isSformat = 1;			// Sinaliza que é um sformat
    3e90:	f88d 3013 	strb.w	r3, [sp, #19]

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
    3e94:	9201      	str	r2, [sp, #4]
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    3e96:	f7ff fe19 	bl	3acc <doprint>
	va_end(args);					// Desmonta args
}
    3e9a:	b006      	add	sp, #24
    3e9c:	f85d eb04 	ldr.w	lr, [sp], #4
    3ea0:	b003      	add	sp, #12
    3ea2:	4770      	bx	lr

Disassembly of section .text.buffer_Init:

00003ea4 <buffer_Init>:
void buffer_Init(buffer_t *buffer, u8 *start, u16 size) {
	// set start pointer of the buffer
	buffer->dataptr = start;
	buffer->size = size;
	// initialize index and length
	buffer->dataindex = 0;
    3ea4:	2300      	movs	r3, #0
// Parametros: 	Endereço da estrutura do buffer, endereço do vetor de dados e o tamanho do vetor
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
void buffer_Init(buffer_t *buffer, u8 *start, u16 size) {
	// set start pointer of the buffer
	buffer->dataptr = start;
    3ea6:	6001      	str	r1, [r0, #0]
	buffer->size = size;
    3ea8:	8082      	strh	r2, [r0, #4]
	// initialize index and length
	buffer->dataindex = 0;
    3eaa:	8103      	strh	r3, [r0, #8]
	buffer->datalength = 0;
    3eac:	80c3      	strh	r3, [r0, #6]
    3eae:	4770      	bx	lr

Disassembly of section .text.buffer_GetFromFront:

00003eb0 <buffer_GetFromFront>:
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Retorna com o primeiro caractere do buffer e retira-o do buffer
// Parametros: 	Ponteiro da estrutura do buffer
// Retorna: 	Primeiro caractere do buffer
//------------------------------------------------------------------------------------------------------------------
u8 buffer_GetFromFront(buffer_t *buffer) {
    3eb0:	4603      	mov	r3, r0
	u8 data = 0;
	
	// check to see if there's data in the buffer
	if(buffer->datalength) {
    3eb2:	88c0      	ldrh	r0, [r0, #6]
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Retorna com o primeiro caractere do buffer e retira-o do buffer
// Parametros: 	Ponteiro da estrutura do buffer
// Retorna: 	Primeiro caractere do buffer
//------------------------------------------------------------------------------------------------------------------
u8 buffer_GetFromFront(buffer_t *buffer) {
    3eb4:	b510      	push	{r4, lr}
	u8 data = 0;
	
	// check to see if there's data in the buffer
	if(buffer->datalength) {
    3eb6:	b280      	uxth	r0, r0
    3eb8:	b1d8      	cbz	r0, 3ef2 <buffer_GetFromFront+0x42>
		// get the first character from buffer
		data = buffer->dataptr[buffer->dataindex];
    3eba:	6819      	ldr	r1, [r3, #0]
    3ebc:	891a      	ldrh	r2, [r3, #8]
    3ebe:	b292      	uxth	r2, r2
    3ec0:	5c88      	ldrb	r0, [r1, r2]
		// move index down and decrement length
		buffer->dataindex++;
    3ec2:	891a      	ldrh	r2, [r3, #8]
    3ec4:	3201      	adds	r2, #1
    3ec6:	b292      	uxth	r2, r2
    3ec8:	811a      	strh	r2, [r3, #8]
		if(buffer->dataindex >= buffer->size) {
    3eca:	8919      	ldrh	r1, [r3, #8]
    3ecc:	889a      	ldrh	r2, [r3, #4]
    3ece:	b289      	uxth	r1, r1
    3ed0:	b292      	uxth	r2, r2
    3ed2:	4291      	cmp	r1, r2
    3ed4:	d309      	bcc.n	3eea <buffer_GetFromFront+0x3a>
			buffer->dataindex %= buffer->size;
    3ed6:	889a      	ldrh	r2, [r3, #4]
    3ed8:	b294      	uxth	r4, r2
    3eda:	891a      	ldrh	r2, [r3, #8]
    3edc:	b292      	uxth	r2, r2
    3ede:	fbb2 f1f4 	udiv	r1, r2, r4
    3ee2:	fb04 2211 	mls	r2, r4, r1, r2
    3ee6:	b292      	uxth	r2, r2
    3ee8:	811a      	strh	r2, [r3, #8]
		}
		buffer->datalength--;
    3eea:	88da      	ldrh	r2, [r3, #6]
    3eec:	3a01      	subs	r2, #1
    3eee:	b292      	uxth	r2, r2
    3ef0:	80da      	strh	r2, [r3, #6]
	}
	
	return data;
}
    3ef2:	bd10      	pop	{r4, pc}

Disassembly of section .text.buffer_AddToEnd:

00003ef4 <buffer_AddToEnd>:
// Parametros: 	Ponteiro para estrutura do buffer e o dados a ser gravados
// Retorna: 	pdPASS se o dados for gravado com sucesso ou erro de acesso
//------------------------------------------------------------------------------------------------------------------
int buffer_AddToEnd(buffer_t* buffer, u8 data) {
	// make sure the buffer has room
	if(buffer->datalength < buffer->size) {
    3ef4:	88c2      	ldrh	r2, [r0, #6]
    3ef6:	8883      	ldrh	r3, [r0, #4]
    3ef8:	b292      	uxth	r2, r2
    3efa:	b29b      	uxth	r3, r3
    3efc:	429a      	cmp	r2, r3
//------------------------------------------------------------------------------------------------------------------
// Descrição: 	Adiciona o caractere no fim do buffer
// Parametros: 	Ponteiro para estrutura do buffer e o dados a ser gravados
// Retorna: 	pdPASS se o dados for gravado com sucesso ou erro de acesso
//------------------------------------------------------------------------------------------------------------------
int buffer_AddToEnd(buffer_t* buffer, u8 data) {
    3efe:	b530      	push	{r4, r5, lr}
	// make sure the buffer has room
	if(buffer->datalength < buffer->size) {
    3f00:	d212      	bcs.n	3f28 <buffer_AddToEnd+0x34>
		// save data byte at end of buffer
		buffer->dataptr[(buffer->dataindex + buffer->datalength) % buffer->size] = data;
    3f02:	6805      	ldr	r5, [r0, #0]
    3f04:	8903      	ldrh	r3, [r0, #8]
    3f06:	88c2      	ldrh	r2, [r0, #6]
    3f08:	8884      	ldrh	r4, [r0, #4]
    3f0a:	b292      	uxth	r2, r2
    3f0c:	b29b      	uxth	r3, r3
    3f0e:	b2a4      	uxth	r4, r4
    3f10:	4413      	add	r3, r2
    3f12:	fb93 f2f4 	sdiv	r2, r3, r4
    3f16:	fb04 3312 	mls	r3, r4, r2, r3
    3f1a:	54e9      	strb	r1, [r5, r3]
		// increment the length
		buffer->datalength++;
    3f1c:	88c3      	ldrh	r3, [r0, #6]
    3f1e:	3301      	adds	r3, #1
    3f20:	b29b      	uxth	r3, r3
    3f22:	80c3      	strh	r3, [r0, #6]
		// return success
		return pdPASS;
    3f24:	2001      	movs	r0, #1
    3f26:	bd30      	pop	{r4, r5, pc}
	} else 
		return errBUFFER_FULL;
    3f28:	f06f 0009 	mvn.w	r0, #9
}
    3f2c:	bd30      	pop	{r4, r5, pc}

Disassembly of section .text.buffer_IsEmpty:

00003f2e <buffer_IsEmpty>:
// Descrição: 	Verifica se o buffer esta vazio
// Parametros: 	Ponteiro para estrutura do buffer
// Retorna: 	Retorna pdTRUE se o buffer está vazio
//------------------------------------------------------------------------------------------------------------------
int buffer_IsEmpty(buffer_t *buffer) {
	if (buffer->datalength == 0)
    3f2e:	88c0      	ldrh	r0, [r0, #6]
    3f30:	b280      	uxth	r0, r0
		return pdTRUE;
	else
		return pdFALSE;
}
    3f32:	fab0 f080 	clz	r0, r0
    3f36:	0940      	lsrs	r0, r0, #5
    3f38:	4770      	bx	lr

Disassembly of section .text.buffer_Clear:

00003f3a <buffer_Clear>:
// Descrição: 	Limpa o buffer de recepção
// Parametros: 	Ponteiro para estrutura do buffer
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
void buffer_Clear(buffer_t* buffer) {
	buffer->datalength = 0;
    3f3a:	2300      	movs	r3, #0
    3f3c:	80c3      	strh	r3, [r0, #6]
    3f3e:	4770      	bx	lr

Disassembly of section .text.put_dump16:

00003f40 <put_dump16>:
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
#ifdef CPU_AVR
void put_dump16 (const u8 *buff, u16 showAddrOffSet, int cnt, u8 mask ) {
#else
void put_dump16 (const u8 *buff, u32 showAddrOffSet, int cnt, u8 mask ) {
    3f40:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    3f42:	4606      	mov	r6, r0
    3f44:	4615      	mov	r5, r2

	// IMPRIME O ENDEREÇO INICIAL (OFFSET)
	#ifdef CPU_AVR
	lprintf("%04x ", showAddrOffSet);
	#else
	lprintf("%08x ", showAddrOffSet);
    3f46:	2001      	movs	r0, #1
    3f48:	460a      	mov	r2, r1
    3f4a:	491b      	ldr	r1, [pc, #108]	; (3fb8 <put_dump16+0x78>)
// Retorna: 	Nada
//------------------------------------------------------------------------------------------------------------------
#ifdef CPU_AVR
void put_dump16 (const u8 *buff, u16 showAddrOffSet, int cnt, u8 mask ) {
#else
void put_dump16 (const u8 *buff, u32 showAddrOffSet, int cnt, u8 mask ) {
    3f4c:	461f      	mov	r7, r3

	// IMPRIME O ENDEREÇO INICIAL (OFFSET)
	#ifdef CPU_AVR
	lprintf("%04x ", showAddrOffSet);
	#else
	lprintf("%08x ", showAddrOffSet);
    3f4e:	f7ff ff7f 	bl	3e50 <rprintf>
	#endif
	
	// IMPRIME HEXDECIMAL
	for(n=0; n<cnt; n++) lprintf(" %02x", buff[n]);
    3f52:	2300      	movs	r3, #0
    3f54:	1c5c      	adds	r4, r3, #1
    3f56:	b2db      	uxtb	r3, r3
    3f58:	42ab      	cmp	r3, r5
    3f5a:	da06      	bge.n	3f6a <put_dump16+0x2a>
    3f5c:	5cf2      	ldrb	r2, [r6, r3]
    3f5e:	4917      	ldr	r1, [pc, #92]	; (3fbc <put_dump16+0x7c>)
    3f60:	2001      	movs	r0, #1
    3f62:	f7ff ff75 	bl	3e50 <rprintf>
    3f66:	4623      	mov	r3, r4
    3f68:	e7f4      	b.n	3f54 <put_dump16+0x14>
		
	// CASO A QUANTIDADE DE BYTES DA LINHA NÃO SEJA O TAMANHO DA MASK
	// Isto preenche a coluna hex com espaços para que a coluna dos caracteres se alinhe com as impressões anteriores
	for(n=cnt; n<mask; n++)	lprintf("   ");
    3f6a:	b2ec      	uxtb	r4, r5
    3f6c:	42bc      	cmp	r4, r7
    3f6e:	d206      	bcs.n	3f7e <put_dump16+0x3e>
    3f70:	4913      	ldr	r1, [pc, #76]	; (3fc0 <put_dump16+0x80>)
    3f72:	2001      	movs	r0, #1
    3f74:	3401      	adds	r4, #1
    3f76:	f7ff ff6b 	bl	3e50 <rprintf>
    3f7a:	b2e4      	uxtb	r4, r4
    3f7c:	e7f6      	b.n	3f6c <put_dump16+0x2c>
	
	// IMPRIME SEPARADOR
	lprintf(" : ");
    3f7e:	4911      	ldr	r1, [pc, #68]	; (3fc4 <put_dump16+0x84>)
    3f80:	2001      	movs	r0, #1
    3f82:	f7ff ff65 	bl	3e50 <rprintf>
	
	// IMPRIME CHAR
	for(n = 0; n < cnt; n++) {
    3f86:	2400      	movs	r4, #0
    3f88:	b2e3      	uxtb	r3, r4
    3f8a:	429d      	cmp	r5, r3
    3f8c:	dd0d      	ble.n	3faa <put_dump16+0x6a>
		//if ((buff[n] < 0x20)||(buff[n] >= 0x7F))
		if ( buff[n] < 0x20 )	lprintf(".");
    3f8e:	5cf2      	ldrb	r2, [r6, r3]
    3f90:	2a1f      	cmp	r2, #31
    3f92:	d804      	bhi.n	3f9e <put_dump16+0x5e>
    3f94:	490c      	ldr	r1, [pc, #48]	; (3fc8 <put_dump16+0x88>)
    3f96:	2001      	movs	r0, #1
    3f98:	f7ff ff5a 	bl	3e50 <rprintf>
    3f9c:	e003      	b.n	3fa6 <put_dump16+0x66>
		else					lprintf("%c", buff[n]);
    3f9e:	490b      	ldr	r1, [pc, #44]	; (3fcc <put_dump16+0x8c>)
    3fa0:	2001      	movs	r0, #1
    3fa2:	f7ff ff55 	bl	3e50 <rprintf>
    3fa6:	3401      	adds	r4, #1
    3fa8:	e7ee      	b.n	3f88 <put_dump16+0x48>
	}
	
	lprintf(CMD_TERMINATOR);
    3faa:	4909      	ldr	r1, [pc, #36]	; (3fd0 <put_dump16+0x90>)
    3fac:	2001      	movs	r0, #1
}
    3fae:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
		//if ((buff[n] < 0x20)||(buff[n] >= 0x7F))
		if ( buff[n] < 0x20 )	lprintf(".");
		else					lprintf("%c", buff[n]);
	}
	
	lprintf(CMD_TERMINATOR);
    3fb2:	f7ff bf4d 	b.w	3e50 <rprintf>
    3fb6:	bf00      	nop
    3fb8:	00005435 	.word	0x00005435
    3fbc:	0000543b 	.word	0x0000543b
    3fc0:	00005441 	.word	0x00005441
    3fc4:	00005445 	.word	0x00005445
    3fc8:	00005430 	.word	0x00005430
    3fcc:	00005432 	.word	0x00005432
    3fd0:	00004f35 	.word	0x00004f35

Disassembly of section .text.xatoi:

00003fd4 <xatoi>:
//				Exemplos: "0x10" ret 16. 	"-100" ret -100. 	"0b1100" ret 12
// Parametros: 	Endereço da string para ser convertida e o endereço da var inteira par retorno da conversão
// Retorna: 	pdTRUE se houve conversão ou pdFALSE caso não foi possivel converter
//------------------------------------------------------------------------------------------------------------------
// Converte ASCII para Integer
int xatoi (char **str, long *res) {
    3fd4:	b570      	push	{r4, r5, r6, lr}
	u32 val;
	u8 c, radix, s = 0;


	while ((c = **str) == ' ') (*str)++;
    3fd6:	6802      	ldr	r2, [r0, #0]
    3fd8:	7813      	ldrb	r3, [r2, #0]
    3fda:	2b20      	cmp	r3, #32
    3fdc:	d102      	bne.n	3fe4 <xatoi+0x10>
    3fde:	3201      	adds	r2, #1
    3fe0:	6002      	str	r2, [r0, #0]
    3fe2:	e7f8      	b.n	3fd6 <xatoi+0x2>
	if (c == '-') {
    3fe4:	2b2d      	cmp	r3, #45	; 0x2d
		s = 1;
		c = *(++(*str));
    3fe6:	bf01      	itttt	eq
    3fe8:	1c53      	addeq	r3, r2, #1
    3fea:	6003      	streq	r3, [r0, #0]
    3fec:	7853      	ldrbeq	r3, [r2, #1]
	u8 c, radix, s = 0;


	while ((c = **str) == ' ') (*str)++;
	if (c == '-') {
		s = 1;
    3fee:	2601      	moveq	r6, #1
// Retorna: 	pdTRUE se houve conversão ou pdFALSE caso não foi possivel converter
//------------------------------------------------------------------------------------------------------------------
// Converte ASCII para Integer
int xatoi (char **str, long *res) {
	u32 val;
	u8 c, radix, s = 0;
    3ff0:	bf18      	it	ne
    3ff2:	2600      	movne	r6, #0
	if (c == '-') {
		s = 1;
		c = *(++(*str));
	}
	
	if (c == '0') {
    3ff4:	2b30      	cmp	r3, #48	; 0x30
    3ff6:	d11c      	bne.n	4032 <xatoi+0x5e>
		c = *(++(*str));
    3ff8:	6802      	ldr	r2, [r0, #0]
    3ffa:	1c53      	adds	r3, r2, #1
    3ffc:	6003      	str	r3, [r0, #0]
    3ffe:	7853      	ldrb	r3, [r2, #1]
		if (c <= ' ') {
    4000:	2b20      	cmp	r3, #32
    4002:	d802      	bhi.n	400a <xatoi+0x36>
			*res = 0; return pdTRUE;
    4004:	2300      	movs	r3, #0
    4006:	600b      	str	r3, [r1, #0]
    4008:	e036      	b.n	4078 <xatoi+0xa4>
		}
		if (c == 'x') {
    400a:	2b78      	cmp	r3, #120	; 0x78
    400c:	d104      	bne.n	4018 <xatoi+0x44>
			radix = 16;
			c = *(++(*str));
    400e:	1c93      	adds	r3, r2, #2
    4010:	6003      	str	r3, [r0, #0]
    4012:	7893      	ldrb	r3, [r2, #2]
		c = *(++(*str));
		if (c <= ' ') {
			*res = 0; return pdTRUE;
		}
		if (c == 'x') {
			radix = 16;
    4014:	2510      	movs	r5, #16
    4016:	e013      	b.n	4040 <xatoi+0x6c>
			c = *(++(*str));
		} else {
			if (c == 'b') {
    4018:	2b62      	cmp	r3, #98	; 0x62
    401a:	d104      	bne.n	4026 <xatoi+0x52>
				radix = 2;
				c = *(++(*str));
    401c:	1c93      	adds	r3, r2, #2
    401e:	6003      	str	r3, [r0, #0]
    4020:	7893      	ldrb	r3, [r2, #2]
		if (c == 'x') {
			radix = 16;
			c = *(++(*str));
		} else {
			if (c == 'b') {
				radix = 2;
    4022:	2502      	movs	r5, #2
    4024:	e00c      	b.n	4040 <xatoi+0x6c>
				c = *(++(*str));
			} else {
				if ((c >= '0')&&(c <= '9'))
    4026:	f1a3 0230 	sub.w	r2, r3, #48	; 0x30
    402a:	2a09      	cmp	r2, #9
    402c:	d907      	bls.n	403e <xatoi+0x6a>
					radix = 8;
				else
					return pdFALSE;
    402e:	2000      	movs	r0, #0
    4030:	bd70      	pop	{r4, r5, r6, pc}
			}
		}
	} else {
		if ((c < '1')||(c > '9'))
    4032:	f1a3 0231 	sub.w	r2, r3, #49	; 0x31
    4036:	2a08      	cmp	r2, #8
    4038:	d8f9      	bhi.n	402e <xatoi+0x5a>
			return pdFALSE;
		radix = 10;
    403a:	250a      	movs	r5, #10
    403c:	e000      	b.n	4040 <xatoi+0x6c>
			if (c == 'b') {
				radix = 2;
				c = *(++(*str));
			} else {
				if ((c >= '0')&&(c <= '9'))
					radix = 8;
    403e:	2508      	movs	r5, #8
	} else {
		if ((c < '1')||(c > '9'))
			return pdFALSE;
		radix = 10;
	}
	val = 0;
    4040:	2400      	movs	r4, #0
	while (c > ' ') {
    4042:	2b20      	cmp	r3, #32
    4044:	d915      	bls.n	4072 <xatoi+0x9e>
		if (c >= 'a') c -= 0x20;
    4046:	2b60      	cmp	r3, #96	; 0x60
    4048:	bf84      	itt	hi
    404a:	3b20      	subhi	r3, #32
    404c:	b2db      	uxtbhi	r3, r3
		c -= '0';
    404e:	f1a3 0230 	sub.w	r2, r3, #48	; 0x30
    4052:	b2d2      	uxtb	r2, r2
		if (c >= 17) {
    4054:	2a10      	cmp	r2, #16
    4056:	d903      	bls.n	4060 <xatoi+0x8c>
			c -= 7;
    4058:	3b37      	subs	r3, #55	; 0x37
    405a:	b2da      	uxtb	r2, r3
			if (c <= 9) return pdFALSE;
    405c:	2a09      	cmp	r2, #9
    405e:	d9e6      	bls.n	402e <xatoi+0x5a>
		}
		if (c >= radix) return pdFALSE;
    4060:	42aa      	cmp	r2, r5
    4062:	d2e4      	bcs.n	402e <xatoi+0x5a>
		val = val * radix + c;
		c = *(++(*str));
    4064:	6803      	ldr	r3, [r0, #0]
		if (c >= 17) {
			c -= 7;
			if (c <= 9) return pdFALSE;
		}
		if (c >= radix) return pdFALSE;
		val = val * radix + c;
    4066:	fb04 2405 	mla	r4, r4, r5, r2
		c = *(++(*str));
    406a:	1c5a      	adds	r2, r3, #1
    406c:	6002      	str	r2, [r0, #0]
    406e:	785b      	ldrb	r3, [r3, #1]
    4070:	e7e7      	b.n	4042 <xatoi+0x6e>
	}
	if (s) val = -val;
    4072:	b106      	cbz	r6, 4076 <xatoi+0xa2>
    4074:	4264      	negs	r4, r4
	*res = val;
    4076:	600c      	str	r4, [r1, #0]
	return pdTRUE;
    4078:	2001      	movs	r0, #1
}
    407a:	bd70      	pop	{r4, r5, r6, pc}

Disassembly of section .text.ledError_Init:

0000407c <ledError_Init>:
static void led_SetupPorts(void);
static void led_State(int st);

#if defined(CPU_ARM_LPC)
static void led_SetupPorts(void) {
	ledERROR_DIR |= ledERROR;
    407c:	4a04      	ldr	r2, [pc, #16]	; (4090 <ledError_Init+0x14>)
    407e:	6813      	ldr	r3, [r2, #0]
    4080:	f043 5300 	orr.w	r3, r3, #536870912	; 0x20000000
    4084:	6013      	str	r3, [r2, #0]
	ledERROR_OFF |= ledERROR;
    4086:	69d3      	ldr	r3, [r2, #28]
    4088:	f043 5300 	orr.w	r3, r3, #536870912	; 0x20000000
    408c:	61d3      	str	r3, [r2, #28]
    408e:	4770      	bx	lr
    4090:	2009c080 	.word	0x2009c080

Disassembly of section .text.ledError_Tick:

00004094 <ledError_Tick>:


// função de sistema para ser chamado a cada 1ms
// o numero do erro representa a quantidade de vezes que led vai piscar. Se for valor 0 deixa o led apagado
void ledError_Tick(void) {
	if (!ledBlink) return;
    4094:	4b1b      	ldr	r3, [pc, #108]	; (4104 <ledError_Tick+0x70>)
}


// função de sistema para ser chamado a cada 1ms
// o numero do erro representa a quantidade de vezes que led vai piscar. Se for valor 0 deixa o led apagado
void ledError_Tick(void) {
    4096:	b570      	push	{r4, r5, r6, lr}
	if (!ledBlink) return;
    4098:	681b      	ldr	r3, [r3, #0]
    409a:	2b00      	cmp	r3, #0
    409c:	d031      	beq.n	4102 <ledError_Tick+0x6e>
	static int count1 = 0;
	static int count2 = 0;
	static int ff = 0;
	static int nTimes = 0;

	if (count1==0) {
    409e:	4a1a      	ldr	r2, [pc, #104]	; (4108 <ledError_Tick+0x74>)
    40a0:	6813      	ldr	r3, [r2, #0]
    40a2:	2b00      	cmp	r3, #0
    40a4:	d12b      	bne.n	40fe <ledError_Tick+0x6a>
		if (count2==0) { // Prepara o intervalo entre as piscadas do led
    40a6:	4b19      	ldr	r3, [pc, #100]	; (410c <ledError_Tick+0x78>)
    40a8:	4c19      	ldr	r4, [pc, #100]	; (4110 <ledError_Tick+0x7c>)
    40aa:	6819      	ldr	r1, [r3, #0]
    40ac:	b931      	cbnz	r1, 40bc <ledError_Tick+0x28>
			count2 = 1000;
    40ae:	f44f 717a 	mov.w	r1, #1000	; 0x3e8
    40b2:	6019      	str	r1, [r3, #0]
			nTimes = 2*(error);
    40b4:	4917      	ldr	r1, [pc, #92]	; (4114 <ledError_Tick+0x80>)
    40b6:	6809      	ldr	r1, [r1, #0]
    40b8:	0049      	lsls	r1, r1, #1
    40ba:	6021      	str	r1, [r4, #0]
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
    40bc:	6821      	ldr	r1, [r4, #0]
    40be:	2900      	cmp	r1, #0
    40c0:	dd11      	ble.n	40e6 <ledError_Tick+0x52>
			if (ff)	led_State(pdOFF); else led_State(pdON);
    40c2:	4b15      	ldr	r3, [pc, #84]	; (4118 <ledError_Tick+0x84>)
    40c4:	6818      	ldr	r0, [r3, #0]
    40c6:	b108      	cbz	r0, 40cc <ledError_Tick+0x38>
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    40c8:	4e14      	ldr	r6, [pc, #80]	; (411c <ledError_Tick+0x88>)
    40ca:	e000      	b.n	40ce <ledError_Tick+0x3a>
    40cc:	4e14      	ldr	r6, [pc, #80]	; (4120 <ledError_Tick+0x8c>)
    40ce:	6835      	ldr	r5, [r6, #0]
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
			ff ^= 1;
    40d0:	f080 0001 	eor.w	r0, r0, #1
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    40d4:	f045 5500 	orr.w	r5, r5, #536870912	; 0x20000000
    40d8:	6035      	str	r5, [r6, #0]

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
			ff ^= 1;
			nTimes--;
    40da:	3901      	subs	r1, #1
			nTimes = 2*(error);
		}

		if (nTimes>0) { // Pisca o led por 250 ms vezes nTimes
			if (ff)	led_State(pdOFF); else led_State(pdON);
			count1 = 250;
    40dc:	25fa      	movs	r5, #250	; 0xfa
    40de:	6015      	str	r5, [r2, #0]
			ff ^= 1;
    40e0:	6018      	str	r0, [r3, #0]
			nTimes--;
    40e2:	6021      	str	r1, [r4, #0]
    40e4:	e009      	b.n	40fa <ledError_Tick+0x66>
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    40e6:	480d      	ldr	r0, [pc, #52]	; (411c <ledError_Tick+0x88>)
			count1 = 250;
			ff ^= 1;
			nTimes--;
		} else { // Mantém o led apagado por 1 segundo
			led_State(pdOFF);
			if (count2) count2--;
    40e8:	681b      	ldr	r3, [r3, #0]
	ledERROR_DIR |= ledERROR;
	ledERROR_OFF |= ledERROR;
}

static void led_State(int st) {
	if (st == pdON) ledERROR_ON |= ledERROR; else ledERROR_OFF |= ledERROR;
    40ea:	6801      	ldr	r1, [r0, #0]
    40ec:	f041 5100 	orr.w	r1, r1, #536870912	; 0x20000000
    40f0:	6001      	str	r1, [r0, #0]
			count1 = 250;
			ff ^= 1;
			nTimes--;
		} else { // Mantém o led apagado por 1 segundo
			led_State(pdOFF);
			if (count2) count2--;
    40f2:	b133      	cbz	r3, 4102 <ledError_Tick+0x6e>
    40f4:	4905      	ldr	r1, [pc, #20]	; (410c <ledError_Tick+0x78>)
    40f6:	3b01      	subs	r3, #1
    40f8:	600b      	str	r3, [r1, #0]
		}
	}

	if (count1) count1--;
    40fa:	6813      	ldr	r3, [r2, #0]
    40fc:	b10b      	cbz	r3, 4102 <ledError_Tick+0x6e>
    40fe:	3b01      	subs	r3, #1
    4100:	6013      	str	r3, [r2, #0]
    4102:	bd70      	pop	{r4, r5, r6, pc}
    4104:	10000df0 	.word	0x10000df0
    4108:	10000de8 	.word	0x10000de8
    410c:	10000df8 	.word	0x10000df8
    4110:	10000dfc 	.word	0x10000dfc
    4114:	10000dec 	.word	0x10000dec
    4118:	10000df4 	.word	0x10000df4
    411c:	2009c09c 	.word	0x2009c09c
    4120:	2009c098 	.word	0x2009c098

Disassembly of section .text.gKey_Init:

00004124 <gKey_Init>:
		// se desejar processar a tecla quando a mesma for pressionada, durante o pressionamento
		//		e quando soltar a tecla
//		gkey_Init(NULL, NULL, &onKeyUp);
		// se desejar processar a tecla somente a mesma for solta
void gKey_Init(pkeyFunc onKdown, pkeyFunc onKpress, pkeyFunc onKup) {
	onKeyDown = onKdown;
    4124:	4b04      	ldr	r3, [pc, #16]	; (4138 <gKey_Init+0x14>)
    4126:	6018      	str	r0, [r3, #0]
	onKeyPress = onKpress;
    4128:	4b04      	ldr	r3, [pc, #16]	; (413c <gKey_Init+0x18>)
    412a:	6019      	str	r1, [r3, #0]
	onKeyUp = onKup;
    412c:	4b04      	ldr	r3, [pc, #16]	; (4140 <gKey_Init+0x1c>)
    412e:	601a      	str	r2, [r3, #0]
	gkey_FastInc = 0; // sem repetição
    4130:	4b04      	ldr	r3, [pc, #16]	; (4144 <gKey_Init+0x20>)
    4132:	2200      	movs	r2, #0
    4134:	601a      	str	r2, [r3, #0]
    4136:	4770      	bx	lr
    4138:	10000e14 	.word	0x10000e14
    413c:	10000e18 	.word	0x10000e18
    4140:	10000e08 	.word	0x10000e08
    4144:	100005e8 	.word	0x100005e8

Disassembly of section .text.gKey_Tick:

00004148 <gKey_Tick>:


// função a ser chamada a cada 1ms
static volatile uint timeRepeat=0;
void gKey_Tick(void) {
	if (timeRepeat) timeRepeat--;
    4148:	4b03      	ldr	r3, [pc, #12]	; (4158 <gKey_Tick+0x10>)
    414a:	681a      	ldr	r2, [r3, #0]
    414c:	b112      	cbz	r2, 4154 <gKey_Tick+0xc>
    414e:	681a      	ldr	r2, [r3, #0]
    4150:	3a01      	subs	r2, #1
    4152:	601a      	str	r2, [r3, #0]
    4154:	4770      	bx	lr
    4156:	bf00      	nop
    4158:	10000e0c 	.word	0x10000e0c

Disassembly of section .text.gKey_Process:

0000415c <gKey_Process>:

// Gerador de enventos para tecla pressioada
// A função gKey_Process vai chamar as funções anexadas em onKdown, onKpress, onKup em gKey_Init
// passando o valor da tecla pressionada. São nessas funções que iremos processar a tecla
// ATENÇÃO: Tecla pressionada deve ter valor > 0. Nenhuma tecla pressionada deve retornar valor 0
void gKey_Process(char key) {
    415c:	b570      	push	{r4, r5, r6, lr}
    static char keyold=0, keynow=0, estado=0;
    static uint repeat=0;

    //verificação da tecla
    keyold = keynow;
    415e:	4a21      	ldr	r2, [pc, #132]	; (41e4 <gKey_Process+0x88>)
    keynow = key;

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    4160:	4d21      	ldr	r5, [pc, #132]	; (41e8 <gKey_Process+0x8c>)
void gKey_Process(char key) {
    static char keyold=0, keynow=0, estado=0;
    static uint repeat=0;

    //verificação da tecla
    keyold = keynow;
    4162:	7813      	ldrb	r3, [r2, #0]
    keynow = key;
    4164:	7010      	strb	r0, [r2, #0]

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    4166:	782a      	ldrb	r2, [r5, #0]

// Gerador de enventos para tecla pressioada
// A função gKey_Process vai chamar as funções anexadas em onKdown, onKpress, onKup em gKey_Init
// passando o valor da tecla pressionada. São nessas funções que iremos processar a tecla
// ATENÇÃO: Tecla pressionada deve ter valor > 0. Nenhuma tecla pressionada deve retornar valor 0
void gKey_Process(char key) {
    4168:	4604      	mov	r4, r0
    keynow = key;

    //repetição rapida?
    //gkey_FastInc = repeat==0;					// Sinaliza se é para incrementar/decrementar mais rápido quando a tecle permanecer pressionada

    switch (estado) {
    416a:	b112      	cbz	r2, 4172 <gKey_Process+0x16>
    416c:	2a01      	cmp	r2, #1
    416e:	d018      	beq.n	41a2 <gKey_Process+0x46>
    4170:	bd70      	pop	{r4, r5, r6, pc}
    case 0: 									// Estado de verificação se tecla foi pressionada
    	repeat = keyREPEAT;						// A cada X segundos incrementos o gkey_FastInc
    4172:	491e      	ldr	r1, [pc, #120]	; (41ec <gKey_Process+0x90>)
    4174:	260a      	movs	r6, #10
    4176:	600e      	str	r6, [r1, #0]
		gkey_FastInc = 0;						// Sinaliza para não incrementar de modo rápido
    4178:	491d      	ldr	r1, [pc, #116]	; (41f0 <gKey_Process+0x94>)
    417a:	600a      	str	r2, [r1, #0]
    	if ((keyold==0)&&(keynow!=0)) {			// Checa se é a descida da tecla, se sim emitir o evento onKeyDown e onKeyPress
    417c:	2b00      	cmp	r3, #0
    417e:	d12f      	bne.n	41e0 <gKey_Process+0x84>
    4180:	2800      	cmp	r0, #0
    4182:	d02d      	beq.n	41e0 <gKey_Process+0x84>
            if (onKeyDown) onKeyDown(key);		// Emitir o evento onKeyDown e onKeyPress
    4184:	4b1b      	ldr	r3, [pc, #108]	; (41f4 <gKey_Process+0x98>)
    4186:	681b      	ldr	r3, [r3, #0]
    4188:	b103      	cbz	r3, 418c <gKey_Process+0x30>
    418a:	4798      	blx	r3
            if (onKeyPress) onKeyPress(key);	// Emitir o evento onKeyPress
    418c:	4b1a      	ldr	r3, [pc, #104]	; (41f8 <gKey_Process+0x9c>)
    418e:	681b      	ldr	r3, [r3, #0]
    4190:	b10b      	cbz	r3, 4196 <gKey_Process+0x3a>
    4192:	4620      	mov	r0, r4
    4194:	4798      	blx	r3
            timeRepeat = keyKEYPRESS_REPEAT1;	// Determina em que tempo vamos repetir o evento onKeyPress após a primeira vez
    4196:	4b19      	ldr	r3, [pc, #100]	; (41fc <gKey_Process+0xa0>)
    4198:	f44f 72fa 	mov.w	r2, #500	; 0x1f4
    419c:	601a      	str	r2, [r3, #0]
    		estado = 1;							// Vá para o estado de verificação de tecla precionada
    419e:	2301      	movs	r3, #1
    41a0:	e007      	b.n	41b2 <gKey_Process+0x56>
    	}
    	break;
    case 1: 									// Estado de verificação se a tecla esta sendo pressionada ou tecla foi solta
    	if ((keyold!=0)&&(keynow==0)) {			// Checa se é a subida da tecla, se sim emitir o evento onKeyUp
    41a2:	b143      	cbz	r3, 41b6 <gKey_Process+0x5a>
    41a4:	b938      	cbnz	r0, 41b6 <gKey_Process+0x5a>
    		if (onKeyUp) onKeyUp(keyold);
    41a6:	4a16      	ldr	r2, [pc, #88]	; (4200 <gKey_Process+0xa4>)
    41a8:	6812      	ldr	r2, [r2, #0]
    41aa:	b10a      	cbz	r2, 41b0 <gKey_Process+0x54>
    41ac:	4618      	mov	r0, r3
    41ae:	4790      	blx	r2
    		estado = 0;							// Volta ao estado para esperar a próxima tecla a ser pressionada
    41b0:	2300      	movs	r3, #0
    41b2:	702b      	strb	r3, [r5, #0]
    41b4:	bd70      	pop	{r4, r5, r6, pc}
    	} else if (timeRepeat == 0) {					// Checa se está na hora de repetir o evento onKeyPress
    41b6:	4b11      	ldr	r3, [pc, #68]	; (41fc <gKey_Process+0xa0>)
    41b8:	681a      	ldr	r2, [r3, #0]
    41ba:	b98a      	cbnz	r2, 41e0 <gKey_Process+0x84>
            timeRepeat = keyKEYPRESS_REPEAT2; 		// Determina em que tempo vamos repetir o evento onKeyPress sucessivamente quando a tecla for mantida pressionada
    41bc:	2264      	movs	r2, #100	; 0x64
    41be:	601a      	str	r2, [r3, #0]
            if (onKeyPress) onKeyPress(key);	// Chama o evento onKeyPress
    41c0:	4b0d      	ldr	r3, [pc, #52]	; (41f8 <gKey_Process+0x9c>)
    41c2:	681b      	ldr	r3, [r3, #0]
    41c4:	b10b      	cbz	r3, 41ca <gKey_Process+0x6e>
    41c6:	4620      	mov	r0, r4
    41c8:	4798      	blx	r3

            // checar o momento de incrementar a var FastInc
            if (repeat) repeat--;
    41ca:	4a08      	ldr	r2, [pc, #32]	; (41ec <gKey_Process+0x90>)
    41cc:	6813      	ldr	r3, [r2, #0]
    41ce:	b10b      	cbz	r3, 41d4 <gKey_Process+0x78>
    41d0:	3b01      	subs	r3, #1
    41d2:	e004      	b.n	41de <gKey_Process+0x82>
            else {
            	repeat = keyREPEAT;
    41d4:	230a      	movs	r3, #10
    41d6:	6013      	str	r3, [r2, #0]
            	gkey_FastInc++;
    41d8:	4a05      	ldr	r2, [pc, #20]	; (41f0 <gKey_Process+0x94>)
    41da:	6813      	ldr	r3, [r2, #0]
    41dc:	3301      	adds	r3, #1
    41de:	6013      	str	r3, [r2, #0]
    41e0:	bd70      	pop	{r4, r5, r6, pc}
    41e2:	bf00      	nop
    41e4:	10000e10 	.word	0x10000e10
    41e8:	10000e04 	.word	0x10000e04
    41ec:	10000e00 	.word	0x10000e00
    41f0:	100005e8 	.word	0x100005e8
    41f4:	10000e14 	.word	0x10000e14
    41f8:	10000e18 	.word	0x10000e18
    41fc:	10000e0c 	.word	0x10000e0c
    4200:	10000e08 	.word	0x10000e08

Disassembly of section .text.beep_SetType:

00004204 <beep_SetType>:

// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Ajusta o controlador a emitir o tipo sonoro
// -------------------------------------------------------------------------------------------------------------------
static void beep_SetType(void) {
	uint x; for(x=0;x<nPULSE_BEEPS;x++) { beep.pulse[x].tOff = 0; beep.pulse[x].tOn = 0;}
    4204:	4b20      	ldr	r3, [pc, #128]	; (4288 <beep_SetType+0x84>)
    4206:	2200      	movs	r2, #0
    4208:	615a      	str	r2, [r3, #20]
    420a:	611a      	str	r2, [r3, #16]
    420c:	61da      	str	r2, [r3, #28]
    420e:	619a      	str	r2, [r3, #24]
    4210:	625a      	str	r2, [r3, #36]	; 0x24
    4212:	621a      	str	r2, [r3, #32]
	beep.index = 0;
    4214:	60da      	str	r2, [r3, #12]
	beep.interval = 0;
    4216:	62da      	str	r2, [r3, #44]	; 0x2c

	switch(beep.type) {
    4218:	685a      	ldr	r2, [r3, #4]
    421a:	3a02      	subs	r2, #2
    421c:	2a04      	cmp	r2, #4
    421e:	d832      	bhi.n	4286 <beep_SetType+0x82>
    4220:	e8df f002 	tbb	[pc, r2]
    4224:	1b090313 	.word	0x1b090313
    4228:	25          	.byte	0x25
    4229:	00          	.byte	0x00
	case beep1SHORTBEEP:
 		beep.nBeeps = 1; // Emitir 1 beep
    422a:	2201      	movs	r2, #1
    422c:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 50; // Primeiro beep 50 ms ligado
    422e:	2232      	movs	r2, #50	; 0x32
    4230:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 50; // Primeiro beep 50 ms desligado
    4232:	615a      	str	r2, [r3, #20]
    4234:	e025      	b.n	4282 <beep_SetType+0x7e>
 		beep.intervalLoad = 0; // sem repetições
		break;
	case beep3SHORTBEEP:
		beep.nBeeps = 3; // Emitir 3 beeps
    4236:	2203      	movs	r2, #3
    4238:	609a      	str	r2, [r3, #8]
		for(x=0;x<3;x++) { beep.pulse[x].tOff = 50; beep.pulse[x].tOn = 50;} // todos os beeps 50ms ligado e desligado
    423a:	2232      	movs	r2, #50	; 0x32
    423c:	615a      	str	r2, [r3, #20]
    423e:	611a      	str	r2, [r3, #16]
    4240:	61da      	str	r2, [r3, #28]
    4242:	619a      	str	r2, [r3, #24]
    4244:	625a      	str	r2, [r3, #36]	; 0x24
    4246:	621a      	str	r2, [r3, #32]
    4248:	e01b      	b.n	4282 <beep_SetType+0x7e>
		beep.intervalLoad = 0; // sem repetições
		break;
	case beepCONTINUOUS_ONOFF:
 		beep.nBeeps = 1; // Emitir 1 beep
    424a:	2201      	movs	r2, #1
    424c:	609a      	str	r2, [r3, #8]
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
 		beep.pulse[0].tOff = 800; // Primeiro beep 800 ms desligado
    424e:	f44f 7148 	mov.w	r1, #800	; 0x320
		for(x=0;x<3;x++) { beep.pulse[x].tOff = 50; beep.pulse[x].tOn = 50;} // todos os beeps 50ms ligado e desligado
		beep.intervalLoad = 0; // sem repetições
		break;
	case beepCONTINUOUS_ONOFF:
 		beep.nBeeps = 1; // Emitir 1 beep
 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    4252:	2264      	movs	r2, #100	; 0x64
    4254:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 800; // Primeiro beep 800 ms desligado
    4256:	6159      	str	r1, [r3, #20]
    4258:	e014      	b.n	4284 <beep_SetType+0x80>
 		beep.intervalLoad = 100; // repetir os beeps a cada 100ms
		break;
	case beepCONTINUOUS_2xONOFF:
		beep.nBeeps = 2; // Emitir 2 beeps
    425a:	2202      	movs	r2, #2
    425c:	609a      	str	r2, [r3, #8]
		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    425e:	2264      	movs	r2, #100	; 0x64
    4260:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 100; // Primeiro beep 100 ms desligado
    4262:	615a      	str	r2, [r3, #20]
 		beep.pulse[1].tOn = 100; // Segundo beep 100 ms ligado
    4264:	619a      	str	r2, [r3, #24]
 		beep.pulse[1].tOff = 100; // Segundo beep 100 ms desligado
    4266:	61da      	str	r2, [r3, #28]
 		beep.intervalLoad = 2000; // repetir os beeps a cada 2000ms
    4268:	f44f 62fa 	mov.w	r2, #2000	; 0x7d0
    426c:	e00a      	b.n	4284 <beep_SetType+0x80>
		break;
	case beep1LONG2SHORTBEEP:
		beep.nBeeps = 3; // Emitir 3 beeps
    426e:	2203      	movs	r2, #3
    4270:	609a      	str	r2, [r3, #8]

 		beep.pulse[0].tOn = 100; // Primeiro beep 100 ms ligado
    4272:	2264      	movs	r2, #100	; 0x64
    4274:	611a      	str	r2, [r3, #16]
 		beep.pulse[0].tOff = 100; // Primeiro beep 100 ms desligado
    4276:	615a      	str	r2, [r3, #20]
 		beep.pulse[1].tOn = 50; // Segundo beep 50 ms ligado
    4278:	2232      	movs	r2, #50	; 0x32
    427a:	619a      	str	r2, [r3, #24]
 		beep.pulse[1].tOff = 50; // Segundo beep 50 ms desligado
    427c:	61da      	str	r2, [r3, #28]
 		beep.pulse[2].tOn = 50; // Terceiro beep 50 ms ligado
    427e:	621a      	str	r2, [r3, #32]
 		beep.pulse[2].tOff = 50; // Terceiro beep 50 ms desligado
    4280:	625a      	str	r2, [r3, #36]	; 0x24
		beep.intervalLoad = 0; // sem repetições
    4282:	2200      	movs	r2, #0
    4284:	629a      	str	r2, [r3, #40]	; 0x28
    4286:	4770      	bx	lr
    4288:	10000e1c 	.word	0x10000e1c

Disassembly of section .text.beep_Init:

0000428c <beep_Init>:

// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Inicializa o gerenciador de beeps
// -------------------------------------------------------------------------------------------------------------------
void beep_Init(void) {
	beep_SetupPorts();
    428c:	4a07      	ldr	r2, [pc, #28]	; (42ac <beep_Init+0x20>)
    428e:	6813      	ldr	r3, [r2, #0]
    4290:	f443 0380 	orr.w	r3, r3, #4194304	; 0x400000
    4294:	6013      	str	r3, [r2, #0]
    4296:	4b06      	ldr	r3, [pc, #24]	; (42b0 <beep_Init+0x24>)
    4298:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
    429c:	601a      	str	r2, [r3, #0]
	beep.power = pdOFF; 	// Mantém desligado e emissão de beeps
    429e:	4b05      	ldr	r3, [pc, #20]	; (42b4 <beep_Init+0x28>)
    42a0:	781a      	ldrb	r2, [r3, #0]
    42a2:	f36f 0200 	bfc	r2, #0, #1
    42a6:	701a      	strb	r2, [r3, #0]
    42a8:	4770      	bx	lr
    42aa:	bf00      	nop
    42ac:	2009c000 	.word	0x2009c000
    42b0:	2009c01c 	.word	0x2009c01c
    42b4:	10000e1c 	.word	0x10000e1c

Disassembly of section .text.beep_Play:

000042b8 <beep_Play>:
//			beep1SHORTBEEP 			Emissão de um beep curto
//			beep3SHORTBEEP 			Emissão de três beeps curtos
//			beepCONTINUOUS_2xONOFF	Emissão de dois beeps curtos em intervalos
//			beep1LONG2SHORTBEEP		Emissão um beep longo e dois beeps curtos
// -------------------------------------------------------------------------------------------------------------------
void beep_Play(uint type) {
    42b8:	b510      	push	{r4, lr}
    42ba:	4c07      	ldr	r4, [pc, #28]	; (42d8 <beep_Play+0x20>)
	if (type) {
    42bc:	b130      	cbz	r0, 42cc <beep_Play+0x14>
		beep.type = type;
    42be:	6060      	str	r0, [r4, #4]
		beep_SetType();
    42c0:	f7ff ffa0 	bl	4204 <beep_SetType>
		beep.power = pdON;
    42c4:	7823      	ldrb	r3, [r4, #0]
    42c6:	f043 0301 	orr.w	r3, r3, #1
    42ca:	e002      	b.n	42d2 <beep_Play+0x1a>
	} else beep.power = pdOFF;
    42cc:	7823      	ldrb	r3, [r4, #0]
    42ce:	f360 0300 	bfi	r3, r0, #0, #1
    42d2:	7023      	strb	r3, [r4, #0]
    42d4:	bd10      	pop	{r4, pc}
    42d6:	bf00      	nop
    42d8:	10000e1c 	.word	0x10000e1c

Disassembly of section .text.beep_Tick:

000042dc <beep_Tick>:
// -------------------------------------------------------------------------------------------------------------------
//static uint interval = 0;

void beep_Tick(void) {
	// Se não é para emitir som, vamos desligar o buzzer e sair fora
	if (beep.power == pdOFF) {
    42dc:	481f      	ldr	r0, [pc, #124]	; (435c <beep_Tick+0x80>)
// -------------------------------------------------------------------------------------------------------------------
// Descrição:	Evento a ser chamado a cada 1ms para control de emissão sonora
// -------------------------------------------------------------------------------------------------------------------
//static uint interval = 0;

void beep_Tick(void) {
    42de:	b510      	push	{r4, lr}
	// Se não é para emitir som, vamos desligar o buzzer e sair fora
	if (beep.power == pdOFF) {
    42e0:	7802      	ldrb	r2, [r0, #0]
    42e2:	07d3      	lsls	r3, r2, #31
    42e4:	d403      	bmi.n	42ee <beep_Tick+0x12>
		beep_BuzzerOFF();
    42e6:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
    42ea:	4b1d      	ldr	r3, [pc, #116]	; (4360 <beep_Tick+0x84>)
    42ec:	e005      	b.n	42fa <beep_Tick+0x1e>
		return;
	}

	// se é o beep acionado direto liga o buzzer e cai fora
	if (beep.type == beepCONTINUOUS) {
    42ee:	6843      	ldr	r3, [r0, #4]
    42f0:	2b01      	cmp	r3, #1
    42f2:	d104      	bne.n	42fe <beep_Tick+0x22>
		beep_BuzzerON();
    42f4:	4b1b      	ldr	r3, [pc, #108]	; (4364 <beep_Tick+0x88>)
    42f6:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
    42fa:	601a      	str	r2, [r3, #0]
		return;
    42fc:	bd10      	pop	{r4, pc}
	}

	// respeitar o tempo entre emissão de beeps quando for de forma continua
	if (beep.interval) beep.interval--;
    42fe:	6ac3      	ldr	r3, [r0, #44]	; 0x2c
    4300:	b10b      	cbz	r3, 4306 <beep_Tick+0x2a>
    4302:	3b01      	subs	r3, #1
    4304:	e022      	b.n	434c <beep_Tick+0x70>
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
    4306:	68c1      	ldr	r1, [r0, #12]
    4308:	1c8b      	adds	r3, r1, #2
    430a:	f850 4033 	ldr.w	r4, [r0, r3, lsl #3]
    430e:	b13c      	cbz	r4, 4320 <beep_Tick+0x44>
			beep_BuzzerON(); // Liga o buzzer
    4310:	4a14      	ldr	r2, [pc, #80]	; (4364 <beep_Tick+0x88>)
    4312:	f44f 0180 	mov.w	r1, #4194304	; 0x400000
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
    4316:	3c01      	subs	r4, #1

	// respeitar o tempo entre emissão de beeps quando for de forma continua
	if (beep.interval) beep.interval--;
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
			beep_BuzzerON(); // Liga o buzzer
    4318:	6011      	str	r1, [r2, #0]
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
    431a:	f840 4033 	str.w	r4, [r0, r3, lsl #3]
    431e:	bd10      	pop	{r4, pc}
		} else if (beep.pulse[beep.index].tOff) { // Checa se é ainda tempo de ficar desativo o buzzer
    4320:	eb00 03c3 	add.w	r3, r0, r3, lsl #3
    4324:	685c      	ldr	r4, [r3, #4]
    4326:	b134      	cbz	r4, 4336 <beep_Tick+0x5a>
			beep_BuzzerOFF(); // desliga o buzzer
    4328:	4a0d      	ldr	r2, [pc, #52]	; (4360 <beep_Tick+0x84>)
    432a:	f44f 0180 	mov.w	r1, #4194304	; 0x400000
			beep.pulse[beep.index].tOff--; // decrementa o tempo de permanecer desligado
    432e:	3c01      	subs	r4, #1
	else {
		if (beep.pulse[beep.index].tOn) { // Checa se ainda é tempo de ficar ativo o buzzer
			beep_BuzzerON(); // Liga o buzzer
			beep.pulse[beep.index].tOn--; // decrementa o tempo de permanecer ligado
		} else if (beep.pulse[beep.index].tOff) { // Checa se é ainda tempo de ficar desativo o buzzer
			beep_BuzzerOFF(); // desliga o buzzer
    4330:	6011      	str	r1, [r2, #0]
			beep.pulse[beep.index].tOff--; // decrementa o tempo de permanecer desligado
    4332:	605c      	str	r4, [r3, #4]
    4334:	bd10      	pop	{r4, pc}
		// Vamos veriricar se fez todos os beeps e se é para tocar de forma continua o não,
		//	se sim vamos recomeçar, senão para tudo
		} else {
			if (beep.index < beep.nBeeps) // Checa se fez todos os beeps
    4336:	6883      	ldr	r3, [r0, #8]
    4338:	4299      	cmp	r1, r3
    433a:	d202      	bcs.n	4342 <beep_Tick+0x66>
				beep.index++; // vai para o próximo beep
    433c:	3101      	adds	r1, #1
    433e:	60c1      	str	r1, [r0, #12]
    4340:	bd10      	pop	{r4, pc}
			else {
				// se fez todos os beeps vamos checar se tem intervalo entre eles, se tiver vamos reiniciar
				// senão pata tudo
				if (beep.intervalLoad) {
    4342:	6a81      	ldr	r1, [r0, #40]	; 0x28
    4344:	b121      	cbz	r1, 4350 <beep_Tick+0x74>
					beep_SetType(); // reinicia as variáveis
    4346:	f7ff ff5d 	bl	4204 <beep_SetType>
					beep.interval = beep.intervalLoad; // Captura o intervalo
    434a:	6a83      	ldr	r3, [r0, #40]	; 0x28
    434c:	62c3      	str	r3, [r0, #44]	; 0x2c
    434e:	bd10      	pop	{r4, pc}
				} else beep.power = pdOFF; // desliga tudo
    4350:	4613      	mov	r3, r2
    4352:	f361 0300 	bfi	r3, r1, #0, #1
    4356:	7003      	strb	r3, [r0, #0]
    4358:	bd10      	pop	{r4, pc}
    435a:	bf00      	nop
    435c:	10000e1c 	.word	0x10000e1c
    4360:	2009c01c 	.word	0x2009c01c
    4364:	2009c018 	.word	0x2009c018

Disassembly of section .text.cli_GetLine:

00004368 <cli_GetLine>:
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    4368:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
  	if (initGet) { // Checa se é incio da entrada de comandos
    436a:	4f35      	ldr	r7, [pc, #212]	; (4440 <cli_GetLine+0xd8>)
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    436c:	4604      	mov	r4, r0
  	if (initGet) { // Checa se é incio da entrada de comandos
    436e:	783b      	ldrb	r3, [r7, #0]
//				bufferLength: tamanho do buffer
//				*prompt: Prompt para ser exibido
// Retorna	:  A quantidade de dados processado no buffer
// -----------------------------------------------------------------------------------------------------------------
//  bufferLength includes the space reserved for the \0
int cli_GetLine (u8 *buffer, int bufferLength, const char *prompt) {
    4370:	460e      	mov	r6, r1
  	if (initGet) { // Checa se é incio da entrada de comandos
    4372:	b143      	cbz	r3, 4386 <cli_GetLine+0x1e>
  		lprintf("%s", prompt);
    4374:	4933      	ldr	r1, [pc, #204]	; (4444 <cli_GetLine+0xdc>)
    4376:	2001      	movs	r0, #1
    4378:	f7ff fd6a 	bl	3e50 <rprintf>
  	  	p = buffer;
    437c:	4b32      	ldr	r3, [pc, #200]	; (4448 <cli_GetLine+0xe0>)
    437e:	601c      	str	r4, [r3, #0]
  	  	*p = '\0';
    4380:	2300      	movs	r3, #0
    4382:	7023      	strb	r3, [r4, #0]
  	  	initGet = 0;
    4384:	703b      	strb	r3, [r7, #0]
  	}

  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
    4386:	4d31      	ldr	r5, [pc, #196]	; (444c <cli_GetLine+0xe4>)
    4388:	4628      	mov	r0, r5
    438a:	f7ff fd5b 	bl	3e44 <lgetchar>
    438e:	2801      	cmp	r0, #1
    4390:	4603      	mov	r3, r0
    4392:	d150      	bne.n	4436 <cli_GetLine+0xce>
	  	switch (c) {
    4394:	782a      	ldrb	r2, [r5, #0]
    4396:	2a0d      	cmp	r2, #13
    4398:	d010      	beq.n	43bc <cli_GetLine+0x54>
    439a:	d804      	bhi.n	43a6 <cli_GetLine+0x3e>
    439c:	2a08      	cmp	r2, #8
    439e:	d018      	beq.n	43d2 <cli_GetLine+0x6a>
    43a0:	2a0a      	cmp	r2, #10
    43a2:	d00b      	beq.n	43bc <cli_GetLine+0x54>
    43a4:	e031      	b.n	440a <cli_GetLine+0xa2>
    43a6:	2a15      	cmp	r2, #21
    43a8:	d101      	bne.n	43ae <cli_GetLine+0x46>
        	}
        	break;
        	break;

	    case 0x15 : // CTRL-U
    		while (p != buffer) {
    43aa:	4d27      	ldr	r5, [pc, #156]	; (4448 <cli_GetLine+0xe0>)
    43ac:	e01f      	b.n	43ee <cli_GetLine+0x86>
  	  	initGet = 0;
  	}

  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
	  	switch (c) {
    43ae:	d32c      	bcc.n	440a <cli_GetLine+0xa2>
    43b0:	2afe      	cmp	r2, #254	; 0xfe
    43b2:	d32a      	bcc.n	440a <cli_GetLine+0xa2>
      		*p = '\0';
      		break;

	    case 0xfe :
    	case 0xff :
        	*buffer++ = c;
    43b4:	7022      	strb	r2, [r4, #0]
        	*buffer = '\0';
    43b6:	2200      	movs	r2, #0
    43b8:	7062      	strb	r2, [r4, #1]
        	return 1;
    43ba:	e03f      	b.n	443c <cli_GetLine+0xd4>
  	//while (1) { // FOI RETIRADO PARA QUE NÃO FIQUE NO LOOP ATÉ CHEGADA DO ENTER, PARA QUE OUTRAS FUNÇÕES SEJAM PROCESSADAS COMO UIP
    if (lgetchar(&c) == pdPASS) {
	  	switch (c) {
		case '\r' : // por causa da tecla enter do prompt no PROTEUS que envia \r
    	case '\n' : // estamos usando o finalizar de comandos "\n" ou "\r\n", logo  vamos podemos ignorar o "\r" e usar "\n"
    		lprintf(CMD_TERMINATOR);
    43bc:	4924      	ldr	r1, [pc, #144]	; (4450 <cli_GetLine+0xe8>)
    43be:	2001      	movs	r0, #1
    43c0:	f7ff fd46 	bl	3e50 <rprintf>
    		initGet = 1;
    43c4:	2301      	movs	r3, #1
    43c6:	703b      	strb	r3, [r7, #0]
    		return strlen ((char *) buffer);
    43c8:	4620      	mov	r0, r4
      	}
    }
  	//}

  	return 0;
}
    43ca:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
	  	switch (c) {
		case '\r' : // por causa da tecla enter do prompt no PROTEUS que envia \r
    	case '\n' : // estamos usando o finalizar de comandos "\n" ou "\r\n", logo  vamos podemos ignorar o "\r" e usar "\n"
    		lprintf(CMD_TERMINATOR);
    		initGet = 1;
    		return strlen ((char *) buffer);
    43ce:	f000 bb71 	b.w	4ab4 <strlen>

    	case '\b' :
    		if (p > buffer) {
    43d2:	4a1d      	ldr	r2, [pc, #116]	; (4448 <cli_GetLine+0xe0>)
    43d4:	6813      	ldr	r3, [r2, #0]
    43d6:	429c      	cmp	r4, r3
    43d8:	f04f 0400 	mov.w	r4, #0
    43dc:	d22d      	bcs.n	443a <cli_GetLine+0xd2>
    			*--p = '\0';
    43de:	1e59      	subs	r1, r3, #1
    43e0:	6011      	str	r1, [r2, #0]
    43e2:	f803 4c01 	strb.w	r4, [r3, #-1]
        		lprintf("\b \b");
    43e6:	491b      	ldr	r1, [pc, #108]	; (4454 <cli_GetLine+0xec>)
    43e8:	f7ff fd32 	bl	3e50 <rprintf>
    43ec:	e025      	b.n	443a <cli_GetLine+0xd2>
        	}
        	break;
        	break;

	    case 0x15 : // CTRL-U
    		while (p != buffer) {
    43ee:	682b      	ldr	r3, [r5, #0]
    43f0:	429c      	cmp	r4, r3
    43f2:	d007      	beq.n	4404 <cli_GetLine+0x9c>
    			lprintf("\b \b");
    43f4:	4917      	ldr	r1, [pc, #92]	; (4454 <cli_GetLine+0xec>)
    43f6:	2001      	movs	r0, #1
    43f8:	f7ff fd2a 	bl	3e50 <rprintf>
            	--p;
    43fc:	682b      	ldr	r3, [r5, #0]
    43fe:	3b01      	subs	r3, #1
    4400:	602b      	str	r3, [r5, #0]
    4402:	e7f4      	b.n	43ee <cli_GetLine+0x86>
	        }
      		*p = '\0';
    4404:	2300      	movs	r3, #0
    4406:	7023      	strb	r3, [r4, #0]
      		break;
    4408:	e018      	b.n	443c <cli_GetLine+0xd4>
        	*buffer++ = c;
        	*buffer = '\0';
        	return 1;
	        		
	    default :
	    	if (p < buffer + bufferLength - 1 && c >= ' ' && c < 0x7f) {
    440a:	490f      	ldr	r1, [pc, #60]	; (4448 <cli_GetLine+0xe0>)
    440c:	3e01      	subs	r6, #1
    440e:	680b      	ldr	r3, [r1, #0]
    4410:	4434      	add	r4, r6
    4412:	42a3      	cmp	r3, r4
    4414:	d20f      	bcs.n	4436 <cli_GetLine+0xce>
    4416:	f1a2 0020 	sub.w	r0, r2, #32
    441a:	285e      	cmp	r0, #94	; 0x5e
    441c:	f04f 0400 	mov.w	r4, #0
    4420:	d80b      	bhi.n	443a <cli_GetLine+0xd2>
        		*p++ = c;
    4422:	1c58      	adds	r0, r3, #1
    4424:	701a      	strb	r2, [r3, #0]
    4426:	6008      	str	r0, [r1, #0]
            	*p = '\0';
    4428:	705c      	strb	r4, [r3, #1]
            	lprintf("%c", c);
    442a:	782a      	ldrb	r2, [r5, #0]
    442c:	490a      	ldr	r1, [pc, #40]	; (4458 <cli_GetLine+0xf0>)
    442e:	2001      	movs	r0, #1
    4430:	f7ff fd0e 	bl	3e50 <rprintf>
    4434:	e001      	b.n	443a <cli_GetLine+0xd2>
	    	break;
      	}
    }
  	//}

  	return 0;
    4436:	2300      	movs	r3, #0
    4438:	e000      	b.n	443c <cli_GetLine+0xd4>
    443a:	4623      	mov	r3, r4
}
    443c:	4618      	mov	r0, r3
    443e:	bdf8      	pop	{r3, r4, r5, r6, r7, pc}
    4440:	1000000c 	.word	0x1000000c
    4444:	00004f50 	.word	0x00004f50
    4448:	10000e50 	.word	0x10000e50
    444c:	10000e54 	.word	0x10000e54
    4450:	00004f35 	.word	0x00004f35
    4454:	00005449 	.word	0x00005449
    4458:	00005432 	.word	0x00005432

Disassembly of section .text.cli_Help:

0000445c <cli_Help>:
// -----------------------------------------------------------------------------------------------------------------
// Descrição:	Exibe a lista de comandos de help dos comandos
// Parametros:
// Retorna:
// -----------------------------------------------------------------------------------------------------------------
int cli_Help (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    445c:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    4460:	2500      	movs	r5, #0
    4462:	462c      	mov	r4, r5
// -----------------------------------------------------------------------------------------------------------------
// Descrição:	Exibe a lista de comandos de help dos comandos
// Parametros:
// Retorna:
// -----------------------------------------------------------------------------------------------------------------
int cli_Help (int argc __attribute__ ((unused)), portCHAR **argv __attribute__ ((unused))) {
    4464:	b08a      	sub	sp, #40	; 0x28
  	unsigned int i;
  	int t;
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));
    4466:	2220      	movs	r2, #32

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    4468:	4e1e      	ldr	r6, [pc, #120]	; (44e4 <cli_Help+0x88>)
  	unsigned int i;
  	int t;
  	int longestCmd;
  	portCHAR spaces [32];

  	memset (spaces, ' ', sizeof (spaces));
    446a:	4611      	mov	r1, r2
    446c:	a802      	add	r0, sp, #8
    446e:	f000 fad3 	bl	4a18 <memset>

  	for (longestCmd = 0, i = 0; cmd_list_active[i].command; i++)
    4472:	6837      	ldr	r7, [r6, #0]
    4474:	3514      	adds	r5, #20
    4476:	197b      	adds	r3, r7, r5
    4478:	f853 0c14 	ldr.w	r0, [r3, #-20]
    447c:	b128      	cbz	r0, 448a <cli_Help+0x2e>
    	if ((t = strlen (cmd_list_active[i].command)) > longestCmd)
    447e:	f000 fb19 	bl	4ab4 <strlen>
    4482:	4284      	cmp	r4, r0
    4484:	bfb8      	it	lt
    4486:	4604      	movlt	r4, r0
    4488:	e7f4      	b.n	4474 <cli_Help+0x18>
      		longestCmd = t;

  	spaces [longestCmd] = '\0';
    448a:	ab0a      	add	r3, sp, #40	; 0x28
    448c:	441c      	add	r4, r3
    448e:	f804 0c20 	strb.w	r0, [r4, #-32]

  	for (i = 0; cmd_list_active[i].command; i++) {
    4492:	4604      	mov	r4, r0
    4494:	6833      	ldr	r3, [r6, #0]
    4496:	591d      	ldr	r5, [r3, r4]
    4498:	191a      	adds	r2, r3, r4
    449a:	b1dd      	cbz	r5, 44d4 <cli_Help+0x78>
    	const tCLI *cl = &cmd_list_active[i];

    	if (cl->cmd_type == CMD_TYPE_FUNCTION)
    449c:	f892 8006 	ldrb.w	r8, [r2, #6]
    		lprintf("%s%s -- %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    44a0:	4628      	mov	r0, r5
  	spaces [longestCmd] = '\0';

  	for (i = 0; cmd_list_active[i].command; i++) {
    	const tCLI *cl = &cmd_list_active[i];

    	if (cl->cmd_type == CMD_TYPE_FUNCTION)
    44a2:	f1b8 0f01 	cmp.w	r8, #1
    44a6:	68d7      	ldr	r7, [r2, #12]
    44a8:	d108      	bne.n	44bc <cli_Help+0x60>
    		lprintf("%s%s -- %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    44aa:	f000 fb03 	bl	4ab4 <strlen>
    44ae:	ab02      	add	r3, sp, #8
    44b0:	4403      	add	r3, r0
    44b2:	9700      	str	r7, [sp, #0]
    44b4:	462a      	mov	r2, r5
    44b6:	490c      	ldr	r1, [pc, #48]	; (44e8 <cli_Help+0x8c>)
    44b8:	4640      	mov	r0, r8
    44ba:	e007      	b.n	44cc <cli_Help+0x70>
    	else
    		lprintf("%s%s -- " CLI_MSG_SUB_LIST " - %s"CMD_TERMINATOR, cl->command, &spaces [strlen (cl->command)], cl->description);
    44bc:	f000 fafa 	bl	4ab4 <strlen>
    44c0:	462a      	mov	r2, r5
    44c2:	ab02      	add	r3, sp, #8
    44c4:	4909      	ldr	r1, [pc, #36]	; (44ec <cli_Help+0x90>)
    44c6:	4403      	add	r3, r0
    44c8:	9700      	str	r7, [sp, #0]
    44ca:	2001      	movs	r0, #1
    44cc:	f7ff fcc0 	bl	3e50 <rprintf>
    44d0:	3414      	adds	r4, #20
    44d2:	e7df      	b.n	4494 <cli_Help+0x38>
  	}

  	lprintf(CLI_MSG_HELP);
    44d4:	4906      	ldr	r1, [pc, #24]	; (44f0 <cli_Help+0x94>)
    44d6:	2001      	movs	r0, #1
    44d8:	f7ff fcba 	bl	3e50 <rprintf>

  	return pdPASS;
}
    44dc:	2001      	movs	r0, #1
    44de:	b00a      	add	sp, #40	; 0x28
    44e0:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    44e4:	10000e4c 	.word	0x10000e4c
    44e8:	0000544d 	.word	0x0000544d
    44ec:	00005459 	.word	0x00005459
    44f0:	0000546f 	.word	0x0000546f

Disassembly of section .text.cli_ArgsParse:

000044f4 <cli_ArgsParse>:
  	P_GET_INIT_ARGS,
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
    44f4:	e92d 47f0 	stmdb	sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
    44f8:	4604      	mov	r4, r0
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
    44fa:	0897      	lsrs	r7, r2, #2
  	P_GET_INIT_ARGS,
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
    44fc:	460e      	mov	r6, r1
    44fe:	4691      	mov	r9, r2
    4500:	4698      	mov	r8, r3
//				Ou seja, retira os espaços em branco do lado dirieto e esquerdo da string
// Parametros: ponteiro da string
// Retorna:		Ponteiro da strinf na posição onde começa o comando
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string
    4502:	f000 fad7 	bl	4ab4 <strlen>
    4506:	3801      	subs	r0, #1
  	P_SET_END_ARGS,
  	P_SET_END_QUOTE
} p_state_t;

int cli_ArgsParse (char *cmd, char **argv, int sizeofArgv, int *argc) {
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
    4508:	3f01      	subs	r7, #1
//				Ou seja, retira os espaços em branco do lado dirieto e esquerdo da string
// Parametros: ponteiro da string
// Retorna:		Ponteiro da strinf na posição onde começa o comando
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string
    450a:	1825      	adds	r5, r4, r0

  	// COLOCO O FINALIZAR LOGO APÓS O COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO DIREITO DA STRING
  	while (t >= s && *t && isspace ((int)*t)) 	// Faça enquanto o endereço t seja maior ou igual ao endereço da string e se o caractere for um whitespace
  		*t-- = '\0'; 						// Posição atual da string recebe nulo e aponto para o endereço anterior na string
    450c:	f04f 0a00 	mov.w	sl, #0
// -----------------------------------------------------------------------------------------------------------------
static char *strtrim (char *s) {
  	char *t = s + strlen (s) - 1; 			// Aponta o endereço para o último caractere da string

  	// COLOCO O FINALIZAR LOGO APÓS O COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO DIREITO DA STRING
  	while (t >= s && *t && isspace ((int)*t)) 	// Faça enquanto o endereço t seja maior ou igual ao endereço da string e se o caractere for um whitespace
    4510:	42ac      	cmp	r4, r5
    4512:	d813      	bhi.n	453c <cli_ArgsParse+0x48>
    4514:	782b      	ldrb	r3, [r5, #0]
    4516:	b18b      	cbz	r3, 453c <cli_ArgsParse+0x48>
    4518:	f000 fa5e 	bl	49d8 <__locale_ctype_ptr>
    451c:	782b      	ldrb	r3, [r5, #0]
    451e:	4418      	add	r0, r3
    4520:	7843      	ldrb	r3, [r0, #1]
    4522:	071b      	lsls	r3, r3, #28
    4524:	d50a      	bpl.n	453c <cli_ArgsParse+0x48>
  		*t-- = '\0'; 						// Posição atual da string recebe nulo e aponto para o endereço anterior na string
    4526:	f805 a901 	strb.w	sl, [r5], #-1
    452a:	e7f1      	b.n	4510 <cli_ArgsParse+0x1c>

  	// ENCONTRA O INICIO DO COMANDO. OU SEJA, RETIRA OS ESPAÇOS EM BRANCO DO LADO ESQUERDO DA STRING
  	while (*s && isspace ((int)*s)) 		// Faça enquanto o endereço s seja menor que o endereço final da string e se o caractere for um whitespace
    452c:	f000 fa54 	bl	49d8 <__locale_ctype_ptr>
    4530:	782b      	ldrb	r3, [r5, #0]
    4532:	3401      	adds	r4, #1
    4534:	4418      	add	r0, r3
    4536:	7843      	ldrb	r3, [r0, #1]
    4538:	0718      	lsls	r0, r3, #28
    453a:	d503      	bpl.n	4544 <cli_ArgsParse+0x50>
    453c:	7823      	ldrb	r3, [r4, #0]
    453e:	4625      	mov	r5, r4
    4540:	2b00      	cmp	r3, #0
    4542:	d1f3      	bne.n	452c <cli_ArgsParse+0x38>
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
  	char *s = strtrim (cmd); 								// Retira espaços em branco ou caracteres de controle do lado direto ou esquerdo da string e captura o endereço do comando
  	
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
    4544:	2400      	movs	r4, #0
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
    4546:	464a      	mov	r2, r9
  	int max_args = (sizeofArgv / sizeof (argv [0])) - 1;	// Determina a quantidade máximo de argumetos que podem ser gravados no argv
  	char *s = strtrim (cmd); 								// Retira espaços em branco ou caracteres de controle do lado direto ou esquerdo da string e captura o endereço do comando
  	
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
    4548:	f8c8 4000 	str.w	r4, [r8]
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
    454c:	4621      	mov	r1, r4
    454e:	4630      	mov	r0, r6
    4550:	f000 fa62 	bl	4a18 <memset>

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
    4554:	46a1      	mov	r9, r4
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
  	
  	while (*s) {											// Fazer para toda os caracteres do comando
    4556:	e010      	b.n	457a <cli_ArgsParse+0x86>

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    4558:	f8d8 3000 	ldr.w	r3, [r8]
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    455c:	6035      	str	r5, [r6, #0]

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    455e:	3301      	adds	r3, #1
    4560:	429f      	cmp	r7, r3
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    4562:	f106 0204 	add.w	r2, r6, #4

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
    4566:	f8c8 3000 	str.w	r3, [r8]
    456a:	d036      	beq.n	45da <cli_ArgsParse+0xe6>
        	}
        	break;

      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos
    456c:	4616      	mov	r6, r2

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
        	    	return errCLI_EXED_ARGS;					// Retorna erro
	          	if (*s == '"')								// Checa se encontramos o caractere aspa. Sinaliza inicio do parametro de string contend espaços em branco internos
    456e:	f815 3b01 	ldrb.w	r3, [r5], #1
    	        	pstate = P_SET_END_QUOTE;				// Vai ao estado de encontrar fim das aspas, isto porque nesta condição consideramos o espaço em branco como conteúdo do parametro 
        	  	else
            		pstate = P_SET_END_ARGS;				// Vai ao estado de de encontrar fim do argumento
    4572:	2b22      	cmp	r3, #34	; 0x22
    4574:	bf0c      	ite	eq
    4576:	2403      	moveq	r4, #3
    4578:	2402      	movne	r4, #2
  	p_state_t pstate = P_WAIT_INIT_ARGS;					// Sinalizo para esperar pelo separado de argumentos que é o espaço em branco

  	*argc = 0;												// Sinaliza que ainda não capturou nenhum argumento
  	memset (argv, 0, sizeofArgv); 							// Preenche os endereços do argv com valores 0, ou seja, limpa todos os endereços
  	
  	while (*s) {											// Fazer para toda os caracteres do comando
    457a:	782b      	ldrb	r3, [r5, #0]
    457c:	b353      	cbz	r3, 45d4 <cli_ArgsParse+0xe0>
    	switch (pstate) {
    457e:	2c03      	cmp	r4, #3
    4580:	d8fc      	bhi.n	457c <cli_ArgsParse+0x88>
    4582:	a201      	add	r2, pc, #4	; (adr r2, 4588 <cli_ArgsParse+0x94>)
    4584:	f852 f024 	ldr.w	pc, [r2, r4, lsl #2]
    4588:	00004599 	.word	0x00004599
    458c:	00004559 	.word	0x00004559
    4590:	000045a9 	.word	0x000045a9
    4594:	000045c7 	.word	0x000045c7
      		// PROCURA O INICIO DO ARGUMENTO
      		case P_WAIT_INIT_ARGS :  {						// Checa se estamos esperando pelo separador de argumentos, que é o espaço em branco
          		if (!isspace ((int)*s))  						// Checa se a posição atual não é um white-space, sinalizador de inicio de arqumento
    4598:	f000 fa1e 	bl	49d8 <__locale_ctype_ptr>
    459c:	782b      	ldrb	r3, [r5, #0]
    459e:	4418      	add	r0, r3
    45a0:	7843      	ldrb	r3, [r0, #1]
    45a2:	0719      	lsls	r1, r3, #28
    45a4:	d514      	bpl.n	45d0 <cli_ArgsParse+0xdc>
    45a6:	e011      	b.n	45cc <cli_ArgsParse+0xd8>
    	    }
        	break;

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
    45a8:	f000 fa16 	bl	49d8 <__locale_ctype_ptr>
    45ac:	782b      	ldrb	r3, [r5, #0]
    45ae:	4418      	add	r0, r3
    45b0:	7842      	ldrb	r2, [r0, #1]
    45b2:	0712      	lsls	r2, r2, #28
    45b4:	d503      	bpl.n	45be <cli_ArgsParse+0xca>
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
    45b6:	f885 9000 	strb.w	r9, [r5]
        	break;

      		// ENCONTRA FIM DO ARGUMENTO E SINALIZA NA POSIÇÃO, ENDEREÇO, DO COMANDO COM O CARACTERE NULO
      		case P_SET_END_ARGS : {
          		if (isspace ((int)*s)) {							// Checa se o caractere atual é um whitespace
            		pstate = P_WAIT_INIT_ARGS;				// Sinaliza para ir a estado para captura do prróximo argumento
    45ba:	2400      	movs	r4, #0
    45bc:	e006      	b.n	45cc <cli_ArgsParse+0xd8>
            		*s = '\0';								// Sinaliza na posição atual que é o fim do argumento atual
          		}  else if (*s == '"')						// Checa se encontramos o caractere aspa. Sinaliza inicio do parametro de string contend espaços em branco internos
            		pstate = P_SET_END_QUOTE;				// Vai ao estado de encontrar fim do argumentos dentro das aspas, isto porque nesta condição consideramos o espaço em branco como conteúdo do parametor 
    45be:	2b22      	cmp	r3, #34	; 0x22
    45c0:	bf08      	it	eq
    45c2:	2403      	moveq	r4, #3
    45c4:	e002      	b.n	45cc <cli_ArgsParse+0xd8>
       		}
        		break;

      		// ECONTRA O FIM DAS ASPAS PARA SINALIZAR FIM DE ARGUMENTO
      		case P_SET_END_QUOTE : {
          		if (*s == '"')	pstate = P_SET_END_ARGS;	// Checa se encontramos o caractere aspa. Sinaliza final do parametro e vá ao estado para procura do fim de argumento
    45c6:	2b22      	cmp	r3, #34	; 0x22
    45c8:	bf08      	it	eq
    45ca:	2402      	moveq	r4, #2
          		
          		s++;										// Aponto para o próximo endereço do caractere do comando
    45cc:	3501      	adds	r5, #1
        	}
        		break;
    45ce:	e7d4      	b.n	457a <cli_ArgsParse+0x86>
  	while (*s) {											// Fazer para toda os caracteres do comando
    	switch (pstate) {
      		// PROCURA O INICIO DO ARGUMENTO
      		case P_WAIT_INIT_ARGS :  {						// Checa se estamos esperando pelo separador de argumentos, que é o espaço em branco
          		if (!isspace ((int)*s))  						// Checa se a posição atual não é um white-space, sinalizador de inicio de arqumento
            		pstate = P_GET_INIT_ARGS;				// Sinalizo para ir para o estado de captura do argumento atual
    45d0:	2401      	movs	r4, #1
    45d2:	e7d2      	b.n	457a <cli_ArgsParse+0x86>
        	}
        		break;
    	}
  	}

  	return pdPASS;												// Retorna que OK
    45d4:	2001      	movs	r0, #1
    45d6:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
      		// CAPTURO A POSIÇÃO, ENDEREÇO, INICIAL DO ARGUMENTO NO VETOR DE COMANDOS
      		case P_GET_INIT_ARGS : {
          		*argv++ = s; 								// Captura o endereço S, posição X do buffer, e aponta para o próxima posição do ponteiro de argumentos

          		if (++*argc == max_args)					// Incremento a quantidade de argumetos encontrado e checa se está no limite máximo de argumentos
        	    	return errCLI_EXED_ARGS;					// Retorna erro
    45da:	f06f 003b 	mvn.w	r0, #59	; 0x3b
        		break;
    	}
  	}

  	return pdPASS;												// Retorna que OK
}
    45de:	e8bd 87f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
    45e2:	bf00      	nop

Disassembly of section .text.cli_ArgsDispatch:

000045e4 <cli_ArgsDispatch>:
//              Valor do retorno da função chamada
//              errCLI_CMD_NOT_FOUND: Se não encontrou o comando digitado na lista de comandos
//              errCLI_MANY_ARGS: Caso tenha muitos argumentos para o comando atual
//              errCLI_FEW_ARGS: Caso tenha pouco argumentos para o comando atual
// -----------------------------------------------------------------------------------------------------------------
int cli_ArgsDispatch (const tCLI *cl, int argc, char **argv) {
    45e4:	e92d 41f0 	stmdb	sp!, {r4, r5, r6, r7, r8, lr}
    45e8:	4604      	mov	r4, r0
    45ea:	460d      	mov	r5, r1
    45ec:	4616      	mov	r6, r2
  	cmd_list_active = cl;
    45ee:	4f20      	ldr	r7, [pc, #128]	; (4670 <cli_ArgsDispatch+0x8c>)
    45f0:	603c      	str	r4, [r7, #0]

  	while (cl->command) { 								// Percorre toda lista de comandos
    45f2:	6820      	ldr	r0, [r4, #0]
    45f4:	2800      	cmp	r0, #0
    45f6:	d036      	beq.n	4666 <cli_ArgsDispatch+0x82>
    	if (!strcmp (cl->command, argv [0])) {			// Checa se o comando atual é o mesmo digitado
    45f8:	6831      	ldr	r1, [r6, #0]
    45fa:	f7fc fd57 	bl	10ac <strcmp>
    45fe:	bb80      	cbnz	r0, 4662 <cli_ArgsDispatch+0x7e>
      		int ret = 0;

      		if ((argc == 2) && !strcmp (argv [1], "?")) { // Checa se foi digitaldo ? para o comando 
    4600:	2d02      	cmp	r5, #2
    4602:	d10c      	bne.n	461e <cli_ArgsDispatch+0x3a>
    4604:	491b      	ldr	r1, [pc, #108]	; (4674 <cli_ArgsDispatch+0x90>)
    4606:	6870      	ldr	r0, [r6, #4]
    4608:	f7fc fd50 	bl	10ac <strcmp>
    460c:	b938      	cbnz	r0, 461e <cli_ArgsDispatch+0x3a>
        		lprintf("%s"CMD_TERMINATOR, cl->parameters);		// Exibe ajuda para os parametros
    460e:	6922      	ldr	r2, [r4, #16]
    4610:	4919      	ldr	r1, [pc, #100]	; (4678 <cli_ArgsDispatch+0x94>)
    4612:	2001      	movs	r0, #1
    4614:	f7ff fc1c 	bl	3e50 <rprintf>
        		ret = pdPASS;
    4618:	2001      	movs	r0, #1
    461a:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else if ((argc - 1) < cl->min_args) {			// Checa se a quantidade de argumentos digitados é menor que o mínimo permitido
    461e:	7922      	ldrb	r2, [r4, #4]
    4620:	4295      	cmp	r5, r2
    4622:	dc07      	bgt.n	4634 <cli_ArgsDispatch+0x50>
        		lprintf(CLI_MSG_FEW_ARGS, cl->min_args);
    4624:	4915      	ldr	r1, [pc, #84]	; (467c <cli_ArgsDispatch+0x98>)
    4626:	2001      	movs	r0, #1
    4628:	f7ff fc12 	bl	3e50 <rprintf>
        		ret = errCLI_FEW_ARGS;
    462c:	f06f 003d 	mvn.w	r0, #61	; 0x3d
    4630:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else if (cl->cmd_type == CMD_TYPE_LIST) {		// Checa se é um comando ou uma nome de outra lista
    4634:	79a3      	ldrb	r3, [r4, #6]
    4636:	1e68      	subs	r0, r5, #1
    4638:	b91b      	cbnz	r3, 4642 <cli_ArgsDispatch+0x5e>
        		ret = cli_ArgsDispatch (cl->cmd_list, argc - 1, &argv [1]); // Chama essa a sub lista
    463a:	68a4      	ldr	r4, [r4, #8]
    463c:	4605      	mov	r5, r0
    463e:	3604      	adds	r6, #4
    4640:	e7d6      	b.n	45f0 <cli_ArgsDispatch+0xc>
      		} else if ((argc - 1) > cl->max_args) {			// Checa se a quantidade de argumentos digitados é maior que o máximo permitido
    4642:	7962      	ldrb	r2, [r4, #5]
    4644:	4290      	cmp	r0, r2
    4646:	dd07      	ble.n	4658 <cli_ArgsDispatch+0x74>
        		lprintf(CLI_MSG_MANY_ARGS, cl->max_args);
    4648:	490d      	ldr	r1, [pc, #52]	; (4680 <cli_ArgsDispatch+0x9c>)
    464a:	2001      	movs	r0, #1
    464c:	f7ff fc00 	bl	3e50 <rprintf>
        		ret = errCLI_MANY_ARGS;
    4650:	f06f 003c 	mvn.w	r0, #60	; 0x3c
    4654:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
      		} else {
        		ret = (*cl->handler) (argc - 1, &argv [1]); // Chama a função anexado a esse comando
    4658:	68a3      	ldr	r3, [r4, #8]
    465a:	1d31      	adds	r1, r6, #4

  	//if (!cl->command)
    	//lprintf(CLI_MSG_UNKNOWN_CMD " \"%sCMD_TERMINATOR, argv [0]);

  	return errCLI_CMD_NOT_FOUND;
}
    465c:	e8bd 41f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, lr}
        		ret = cli_ArgsDispatch (cl->cmd_list, argc - 1, &argv [1]); // Chama essa a sub lista
      		} else if ((argc - 1) > cl->max_args) {			// Checa se a quantidade de argumentos digitados é maior que o máximo permitido
        		lprintf(CLI_MSG_MANY_ARGS, cl->max_args);
        		ret = errCLI_MANY_ARGS;
      		} else {
        		ret = (*cl->handler) (argc - 1, &argv [1]); // Chama a função anexado a esse comando
    4660:	4718      	bx	r3
        	}

      		return ret;										// Retorna o valor de retorno da função ou 0 se não chamou função alguma
    	}

    	cl++;											// aponta para o próximo comando na lista 
    4662:	3414      	adds	r4, #20
    4664:	e7c5      	b.n	45f2 <cli_ArgsDispatch+0xe>
  	}

  	//if (!cl->command)
    	//lprintf(CLI_MSG_UNKNOWN_CMD " \"%sCMD_TERMINATOR, argv [0]);

  	return errCLI_CMD_NOT_FOUND;
    4666:	f06f 003e 	mvn.w	r0, #62	; 0x3e
}
    466a:	e8bd 81f0 	ldmia.w	sp!, {r4, r5, r6, r7, r8, pc}
    466e:	bf00      	nop
    4670:	10000e4c 	.word	0x10000e4c
    4674:	0000549a 	.word	0x0000549a
    4678:	0000546b 	.word	0x0000546b
    467c:	0000549c 	.word	0x0000549c
    4680:	000054bd 	.word	0x000054bd

Disassembly of section .text.lcd_command:

00004684 <lcd_command>:
  	_row_offsets[1] = row1;
  	_row_offsets[2] = row2;
  	_row_offsets[3] = row3;
}

static inline void lcd_command(u8 command) {
    4684:	b510      	push	{r4, lr}
    4686:	4604      	mov	r4, r0
u8 _displaymode;
u8 _displayfunction;

// espera até o display estiver desocupado
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
    4688:	2000      	movs	r0, #0
    468a:	f000 f8ed 	bl	4868 <lcd_read>
    468e:	0603      	lsls	r3, r0, #24
    4690:	d4fa      	bmi.n	4688 <lcd_command+0x4>
  	_row_offsets[3] = row3;
}

static inline void lcd_command(u8 command) {
  	lcd_busy();
	lcd_write_command(command);
    4692:	4620      	mov	r0, r4
}
    4694:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
  	_row_offsets[3] = row3;
}

static inline void lcd_command(u8 command) {
  	lcd_busy();
	lcd_write_command(command);
    4698:	2100      	movs	r1, #0
    469a:	f000 b92d 	b.w	48f8 <lcd_write>

Disassembly of section .text.lcd_PutChar:

0000469e <lcd_PutChar>:
}

// Imprime um caractere no display, no endereço atual da DDRAM apontado pelo reg AC.
//	O reg AC é incrementado automaticamente
// Esta função também é usada pelo rprintf
int lcd_PutChar(n16 ch) {
    469e:	b510      	push	{r4, lr}
    46a0:	4604      	mov	r4, r0
u8 _displaymode;
u8 _displayfunction;

// espera até o display estiver desocupado
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
    46a2:	2000      	movs	r0, #0
    46a4:	f000 f8e0 	bl	4868 <lcd_read>
    46a8:	0603      	lsls	r3, r0, #24
    46aa:	d4fa      	bmi.n	46a2 <lcd_PutChar+0x4>
// Imprime um caractere no display, no endereço atual da DDRAM apontado pelo reg AC.
//	O reg AC é incrementado automaticamente
// Esta função também é usada pelo rprintf
int lcd_PutChar(n16 ch) {
	lcd_busy();
	lcd_write_data((u8)ch);
    46ac:	b2e0      	uxtb	r0, r4
    46ae:	2101      	movs	r1, #1
    46b0:	f000 f922 	bl	48f8 <lcd_write>
	return (int)ch;												// Retorna com o caractere a ser TX
}
    46b4:	4620      	mov	r0, r4
    46b6:	bd10      	pop	{r4, pc}

Disassembly of section .text.lcd_Clear:

000046b8 <lcd_Clear>:
  	_displaymode = LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT;
  	// set the entry mode
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
}

void lcd_Clear(void) {
    46b8:	b508      	push	{r3, lr}
  lcd_command(LCD_CLEAR_DISPLAY);  // clear display, set cursor position to zero
    46ba:	2001      	movs	r0, #1
    46bc:	f7ff ffe2 	bl	4684 <lcd_command>
  delay_ms(LCD_DELAY_HOME);  // this command takes a long time!
}
    46c0:	e8bd 4008 	ldmia.w	sp!, {r3, lr}
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
}

void lcd_Clear(void) {
  lcd_command(LCD_CLEAR_DISPLAY);  // clear display, set cursor position to zero
  delay_ms(LCD_DELAY_HOME);  // this command takes a long time!
    46c4:	4801      	ldr	r0, [pc, #4]	; (46cc <lcd_Clear+0x14>)
    46c6:	f7fd ba35 	b.w	1b34 <delay>
    46ca:	bf00      	nop
    46cc:	000101d0 	.word	0x000101d0

Disassembly of section .text.lcd_SetCursor:

000046d0 <lcd_SetCursor>:
}

void lcd_SetCursor(u8 col, u8 row) {
  const uint max_lines = sizeof(_row_offsets) / sizeof(*_row_offsets);
  if ( row >= max_lines ) row = max_lines - 1;    // we count rows starting w/0
  if ( row >= _numlines ) row = _numlines - 1;    // we count rows starting w/0
    46d0:	4b08      	ldr	r3, [pc, #32]	; (46f4 <lcd_SetCursor+0x24>)
    46d2:	2903      	cmp	r1, #3
    46d4:	781b      	ldrb	r3, [r3, #0]
    46d6:	bf28      	it	cs
    46d8:	2103      	movcs	r1, #3
    46da:	428b      	cmp	r3, r1
    46dc:	bf9c      	itt	ls
    46de:	f103 33ff 	addls.w	r3, r3, #4294967295
    46e2:	b2d9      	uxtbls	r1, r3

  lcd_command(LCD_SET_DDRAM_ADDR | (col + _row_offsets[row]));
    46e4:	4b04      	ldr	r3, [pc, #16]	; (46f8 <lcd_SetCursor+0x28>)
    46e6:	5c5b      	ldrb	r3, [r3, r1]
    46e8:	4418      	add	r0, r3
    46ea:	f060 007f 	orn	r0, r0, #127	; 0x7f
    46ee:	b2c0      	uxtb	r0, r0
    46f0:	f7ff bfc8 	b.w	4684 <lcd_command>
    46f4:	100005f1 	.word	0x100005f1
    46f8:	100005ec 	.word	0x100005ec

Disassembly of section .text.lcd_Display:

000046fc <lcd_Display>:
  _displaycontrol &= ~LCD_DISPLAY_ON;
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
}

void lcd_Display(void) {
  _displaycontrol |= LCD_DISPLAY_ON;
    46fc:	4b04      	ldr	r3, [pc, #16]	; (4710 <lcd_Display+0x14>)
    46fe:	7818      	ldrb	r0, [r3, #0]
    4700:	f040 0204 	orr.w	r2, r0, #4
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
    4704:	f040 000c 	orr.w	r0, r0, #12
  _displaycontrol &= ~LCD_DISPLAY_ON;
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
}

void lcd_Display(void) {
  _displaycontrol |= LCD_DISPLAY_ON;
    4708:	701a      	strb	r2, [r3, #0]
  lcd_command(LCD_DISPLAY_CONTROL | _displaycontrol);
    470a:	f7ff bfbb 	b.w	4684 <lcd_command>
    470e:	bf00      	nop
    4710:	100005f0 	.word	0x100005f0

Disassembly of section .text.lcd_Init:

00004714 <lcd_Init>:
// Inicializa o display
// parametros:
//	cols: Número de colunas do LCD
//	lines: Número de linhas do LCD
//  dotsize: Tamanho da fonte em pontos: LCD_5x8DOTS ou LCD_5x10DOTS
void lcd_Init(u8 cols, u8 lines, u8 dotsize) {
    4714:	b5f8      	push	{r3, r4, r5, r6, r7, lr}
    4716:	460e      	mov	r6, r1
    4718:	4617      	mov	r7, r2
    471a:	4605      	mov	r5, r0
	_displayfunction = LCD_4BIT_MODE | LCD_1LINE | dotsize;
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_4BITS)
	lcd_config_ports();
	_displayfunction = LCD_4BIT_MODE | LCD_1LINE | dotsize;
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_8BITS)
	lcd_config_ports();
    471c:	f000 f890 	bl	4840 <lcd_config_ports>
    4720:	4c21      	ldr	r4, [pc, #132]	; (47a8 <lcd_Init+0x94>)
	_displayfunction = LCD_8BIT_MODE | LCD_1LINE | dotsize;
	#endif

  	if (lines > 1) _displayfunction |= LCD_2LINE;
    4722:	2e01      	cmp	r6, #1
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_4BITS)
	lcd_config_ports();
	_displayfunction = LCD_4BIT_MODE | LCD_1LINE | dotsize;
	#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_8BITS)
	lcd_config_ports();
	_displayfunction = LCD_8BIT_MODE | LCD_1LINE | dotsize;
    4724:	bf94      	ite	ls
    4726:	f047 0310 	orrls.w	r3, r7, #16
	#endif

  	if (lines > 1) _displayfunction |= LCD_2LINE;
    472a:	f047 0318 	orrhi.w	r3, r7, #24
    472e:	7023      	strb	r3, [r4, #0]
  	_numlines = lines;
    4730:	4b1e      	ldr	r3, [pc, #120]	; (47ac <lcd_Init+0x98>)
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
}

static void lcd_SetRowOffsets(int row0, int row1, int row2, int row3) {
  	_row_offsets[0] = row0;
    4732:	2200      	movs	r2, #0
	lcd_config_ports();
	_displayfunction = LCD_8BIT_MODE | LCD_1LINE | dotsize;
	#endif

  	if (lines > 1) _displayfunction |= LCD_2LINE;
  	_numlines = lines;
    4734:	701e      	strb	r6, [r3, #0]
static void lcd_busy(void)	{
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
}

static void lcd_SetRowOffsets(int row0, int row1, int row2, int row3) {
  	_row_offsets[0] = row0;
    4736:	4b1e      	ldr	r3, [pc, #120]	; (47b0 <lcd_Init+0x9c>)
    4738:	701a      	strb	r2, [r3, #0]
  	_row_offsets[1] = row1;
    473a:	2240      	movs	r2, #64	; 0x40
  	_row_offsets[2] = row2;
    473c:	709d      	strb	r5, [r3, #2]
  	_row_offsets[3] = row3;
    473e:	4415      	add	r5, r2
	while (lcd_read_command() & 0x80); // Se bit 7 for 1 sinaliza display está ocupado
}

static void lcd_SetRowOffsets(int row0, int row1, int row2, int row3) {
  	_row_offsets[0] = row0;
  	_row_offsets[1] = row1;
    4740:	705a      	strb	r2, [r3, #1]
  	_row_offsets[2] = row2;
  	_row_offsets[3] = row3;
    4742:	70dd      	strb	r5, [r3, #3]
  	_numlines = lines;

  	lcd_SetRowOffsets(0x00, 0x40, 0x00 + cols, 0x40 + cols);

  	// for some 1 line displays you can select a 10 pixel high font
  	if ((dotsize != LCD_5x8DOTS) && (lines == 1)) _displayfunction |= LCD_5x10DOTS;
    4744:	b12f      	cbz	r7, 4752 <lcd_Init+0x3e>
    4746:	2e01      	cmp	r6, #1
    4748:	bf02      	ittt	eq
    474a:	7823      	ldrbeq	r3, [r4, #0]
    474c:	f043 0304 	orreq.w	r3, r3, #4
    4750:	7023      	strbeq	r3, [r4, #0]

  	// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
  	// according to datasheet, we need at least 40ms after power rises above 2.7V
  	// before sending commands. CPU can turn on way before 4.5V so we'll wait 50
  	delay_ms(LCD_DELAY_INIT);
    4752:	4818      	ldr	r0, [pc, #96]	; (47b4 <lcd_Init+0xa0>)
    4754:	f7fd f9ee 	bl	1b34 <delay>

    // this is according to the hitachi HD44780 datasheet
    // page 45 figure 23
    // Send function set command sequence
	lcd_write_init(0x30);	// Function set (Interface is 8 bits long.)
    4758:	2100      	movs	r1, #0
    475a:	2030      	movs	r0, #48	; 0x30
    475c:	f000 f8cc 	bl	48f8 <lcd_write>
    delay_ms(5);  				// wait more than 4.1ms
    4760:	4815      	ldr	r0, [pc, #84]	; (47b8 <lcd_Init+0xa4>)
    4762:	f7fd f9e7 	bl	1b34 <delay>
	lcd_write_init(0x30);	// Function set (Interface is 8 bits long.)
    4766:	2100      	movs	r1, #0
    4768:	2030      	movs	r0, #48	; 0x30
    476a:	f000 f8c5 	bl	48f8 <lcd_write>
	delay_us(150);				// wait more than 100us
    476e:	f241 3088 	movw	r0, #5000	; 0x1388
    4772:	f7fd f9df 	bl	1b34 <delay>
	lcd_write_init(0x30);	// Function set (Interface is 8 bits long.)
    4776:	2100      	movs	r1, #0
    4778:	2030      	movs	r0, #48	; 0x30
    477a:	f000 f8bd 	bl	48f8 <lcd_write>
	#if (LCD_CONNECTION == LCD_CONNECTION_PCF8574) || (LCD_CONNECTION == LCD_CONNECTION_GPIO_4BITS)
	lcd_write_init(LCD_FUNCTION_SET | LCD_4BIT_MODE);
	#endif

	// finally, set # lines, font size, etc.
	lcd_command(LCD_FUNCTION_SET | _displayfunction);
    477e:	7820      	ldrb	r0, [r4, #0]
    4780:	f040 0020 	orr.w	r0, r0, #32
    4784:	f7ff ff7e 	bl	4684 <lcd_command>

  	// turn the display on with no cursor or blinking default
  	_displaycontrol = LCD_DISPLAY_ON | LCD_CURSOR_OFF | LCD_BLINK_OFF;
    4788:	4b0c      	ldr	r3, [pc, #48]	; (47bc <lcd_Init+0xa8>)
    478a:	2204      	movs	r2, #4
    478c:	701a      	strb	r2, [r3, #0]
  	lcd_Display();
    478e:	f7ff ffb5 	bl	46fc <lcd_Display>

  	// clear it off
  	lcd_Clear();
    4792:	f7ff ff91 	bl	46b8 <lcd_Clear>

  	// Initialize to default text direction (for romance languages)
  	_displaymode = LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT;
    4796:	4b0a      	ldr	r3, [pc, #40]	; (47c0 <lcd_Init+0xac>)
    4798:	2202      	movs	r2, #2
    479a:	701a      	strb	r2, [r3, #0]
  	// set the entry mode
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
    479c:	2006      	movs	r0, #6
}
    479e:	e8bd 40f8 	ldmia.w	sp!, {r3, r4, r5, r6, r7, lr}
  	lcd_Clear();

  	// Initialize to default text direction (for romance languages)
  	_displaymode = LCD_ENTRY_LEFT | LCD_ENTRY_SHIFT_DECREMENT;
  	// set the entry mode
  	lcd_command(LCD_ENTRY_MODE_SET | _displaymode);
    47a2:	f7ff bf6f 	b.w	4684 <lcd_command>
    47a6:	bf00      	nop
    47a8:	100005f3 	.word	0x100005f3
    47ac:	100005f1 	.word	0x100005f1
    47b0:	100005ec 	.word	0x100005ec
    47b4:	000a2990 	.word	0x000a2990
    47b8:	00028870 	.word	0x00028870
    47bc:	100005f0 	.word	0x100005f0
    47c0:	100005f2 	.word	0x100005f2

Disassembly of section .text.lcd_printfInit:

000047c4 <lcd_printfInit>:

#if (LCD_USE_PRINTF == pdON)
#include "stdio_uc.h"
static uint devicePrintf = 0;
u8 _cols;
void lcd_printfInit(uint cols, uint dev) {
    47c4:	460b      	mov	r3, r1
	_cols = cols;
    47c6:	4a04      	ldr	r2, [pc, #16]	; (47d8 <lcd_printfInit+0x14>)
    47c8:	7010      	strb	r0, [r2, #0]
	devicePrintf = dev;
    47ca:	4a04      	ldr	r2, [pc, #16]	; (47dc <lcd_printfInit+0x18>)
	rprintf_RegisterDev(dev, lcd_PutChar);								// Anexa a função ao printf
    47cc:	b2d8      	uxtb	r0, r3
#include "stdio_uc.h"
static uint devicePrintf = 0;
u8 _cols;
void lcd_printfInit(uint cols, uint dev) {
	_cols = cols;
	devicePrintf = dev;
    47ce:	6011      	str	r1, [r2, #0]
	rprintf_RegisterDev(dev, lcd_PutChar);								// Anexa a função ao printf
    47d0:	4903      	ldr	r1, [pc, #12]	; (47e0 <lcd_printfInit+0x1c>)
    47d2:	f7ff b951 	b.w	3a78 <rprintf_RegisterDev>
    47d6:	bf00      	nop
    47d8:	100005f4 	.word	0x100005f4
    47dc:	10000e58 	.word	0x10000e58
    47e0:	0000469f 	.word	0x0000469f

Disassembly of section .text.lcd_printf:

000047e4 <lcd_printf>:
}

// faz o mesmo que rprintf, porém acrescenta espaços vazios para preencher toda a linha,
//	apagando os caracteres impressos anteriormente
void lcd_printf(const cpchar fmt, ...) {
    47e4:	b40f      	push	{r0, r1, r2, r3}
    47e6:	b510      	push	{r4, lr}
    47e8:	b096      	sub	sp, #88	; 0x58
    47ea:	aa18      	add	r2, sp, #96	; 0x60
    47ec:	f852 1b04 	ldr.w	r1, [r2], #4
	string s;
	tPrint output;

	output.device = 0;
    47f0:	2300      	movs	r3, #0
    47f2:	f88d 3014 	strb.w	r3, [sp, #20]
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
    47f6:	ac06      	add	r4, sp, #24
	output.isSformat = 1;			// Sinaliza que é um sformat
    47f8:	2301      	movs	r3, #1

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    47fa:	a802      	add	r0, sp, #8
	string s;
	tPrint output;

	output.device = 0;
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
	output.isSformat = 1;			// Sinaliza que é um sformat
    47fc:	f88d 3013 	strb.w	r3, [sp, #19]

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
    4800:	9201      	str	r2, [sp, #4]
void lcd_printf(const cpchar fmt, ...) {
	string s;
	tPrint output;

	output.device = 0;
	output.buf = s;					// Sinaliza qual buffer para armazenar a formatação de string. Também sinaliza que é uma formatação de string e não uma impressão em dipositivo
    4802:	9402      	str	r4, [sp, #8]
	output.isSformat = 1;			// Sinaliza que é um sformat

	va_list args;					// Cria var para captura de argumentos (fmt) no stack da chamada de função
	va_start(args, fmt);			// Captura os argumentos após fmt
	doprint(&output, fmt, args);	// Faz a formatação da string com ftm e args e manda imprimir
    4804:	f7ff f962 	bl	3acc <doprint>
	va_end(args);					// Desmonta args

	uint len = strlen(s);
    4808:	4620      	mov	r0, r4
    480a:	f000 f953 	bl	4ab4 <strlen>
	uint x; for (x=len;x<_cols;x++) s[x]=' ';
    480e:	4b09      	ldr	r3, [pc, #36]	; (4834 <lcd_printf+0x50>)
    4810:	2220      	movs	r2, #32
    4812:	781b      	ldrb	r3, [r3, #0]
    4814:	4298      	cmp	r0, r3
    4816:	d202      	bcs.n	481e <lcd_printf+0x3a>
    4818:	5422      	strb	r2, [r4, r0]
    481a:	3001      	adds	r0, #1
    481c:	e7fa      	b.n	4814 <lcd_printf+0x30>
	rprintf(devicePrintf, "%s", s);
    481e:	4b06      	ldr	r3, [pc, #24]	; (4838 <lcd_printf+0x54>)
    4820:	4622      	mov	r2, r4
    4822:	4906      	ldr	r1, [pc, #24]	; (483c <lcd_printf+0x58>)
    4824:	7818      	ldrb	r0, [r3, #0]
    4826:	f7ff fb13 	bl	3e50 <rprintf>
}
    482a:	b016      	add	sp, #88	; 0x58
    482c:	e8bd 4010 	ldmia.w	sp!, {r4, lr}
    4830:	b004      	add	sp, #16
    4832:	4770      	bx	lr
    4834:	100005f4 	.word	0x100005f4
    4838:	10000e58 	.word	0x10000e58
    483c:	00004f50 	.word	0x00004f50

Disassembly of section .text.lcd_config_ports:

00004840 <lcd_config_ports>:

	LCD_PORTDATA_DIR &= ~(LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4); // Pinos dos dados como entrada
}
#elif (LCD_CONNECTION == LCD_CONNECTION_GPIO_8BITS)
void lcd_config_ports(void)	{
	LCD_PORTDATA_DIR &= ~(LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como entrada
    4840:	4a08      	ldr	r2, [pc, #32]	; (4864 <lcd_config_ports+0x24>)
    4842:	6813      	ldr	r3, [r2, #0]
    4844:	f423 737f 	bic.w	r3, r3, #1020	; 0x3fc
    4848:	6013      	str	r3, [r2, #0]
	LCD_PORTCTRL_DIR |= (LCD_PIN_RS|LCD_PIN_WR|LCD_PIN_E); // Pinos de controle como saida
    484a:	f852 3c20 	ldr.w	r3, [r2, #-32]
    484e:	f043 73e0 	orr.w	r3, r3, #29360128	; 0x1c00000
    4852:	f842 3c20 	str.w	r3, [r2, #-32]
	LCD_PORTCTRL_CLR |= LCD_PIN_E;
    4856:	f852 3c04 	ldr.w	r3, [r2, #-4]
    485a:	f043 7380 	orr.w	r3, r3, #16777216	; 0x1000000
    485e:	f842 3c04 	str.w	r3, [r2, #-4]
    4862:	4770      	bx	lr
    4864:	2009c040 	.word	0x2009c040

Disassembly of section .text.lcd_read:

00004868 <lcd_read>:
// 		rs: 0: Sinaliza ler um comando
//			1: Sinaliza ler um dado
u8 lcd_read(u8 rs) {
	u8 value = 0;

	LCD_PORTCTRL_SET = LCD_PIN_WR;			// WR = 1;
    4868:	4b20      	ldr	r3, [pc, #128]	; (48ec <lcd_read+0x84>)
    486a:	f44f 0200 	mov.w	r2, #8388608	; 0x800000
//		wr: 1: Sinaliza leitura
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza ler um comando
//			1: Sinaliza ler um dado
u8 lcd_read(u8 rs) {
    486e:	b510      	push	{r4, lr}
	u8 value = 0;

	LCD_PORTCTRL_SET = LCD_PIN_WR;			// WR = 1;
    4870:	601a      	str	r2, [r3, #0]
    4872:	4c1f      	ldr	r4, [pc, #124]	; (48f0 <lcd_read+0x88>)
    4874:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
    4878:	b108      	cbz	r0, 487e <lcd_read+0x16>
    487a:	601a      	str	r2, [r3, #0]
    487c:	e000      	b.n	4880 <lcd_read+0x18>
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
    487e:	6022      	str	r2, [r4, #0]
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
    4880:	f04f 7280 	mov.w	r2, #16777216	; 0x1000000
	delay_us(LCD_DELAY);
    4884:	2021      	movs	r0, #33	; 0x21
	u8 value = 0;

	LCD_PORTCTRL_SET = LCD_PIN_WR;			// WR = 1;
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
    4886:	601a      	str	r2, [r3, #0]
	delay_us(LCD_DELAY);
    4888:	f7fd f954 	bl	1b34 <delay>

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
    488c:	4b19      	ldr	r3, [pc, #100]	; (48f4 <lcd_read+0x8c>)
    488e:	681a      	ldr	r2, [r3, #0]
    4890:	f412 7f00 	tst.w	r2, #512	; 0x200
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
    4894:	681a      	ldr	r2, [r3, #0]
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
    4896:	bf0c      	ite	eq
    4898:	2000      	moveq	r0, #0
    489a:	2080      	movne	r0, #128	; 0x80
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
    489c:	05d1      	lsls	r1, r2, #23
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
    489e:	681a      	ldr	r2, [r3, #0]
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
    48a0:	bf44      	itt	mi
    48a2:	f040 0040 	orrmi.w	r0, r0, #64	; 0x40
    48a6:	b2c0      	uxtbmi	r0, r0
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
    48a8:	0612      	lsls	r2, r2, #24
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
    48aa:	681a      	ldr	r2, [r3, #0]
	LCD_PORTCTRL_SET = LCD_PIN_E;			// E = 1
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
    48ac:	bf48      	it	mi
    48ae:	f040 0020 	orrmi.w	r0, r0, #32
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
    48b2:	0651      	lsls	r1, r2, #25
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
    48b4:	681a      	ldr	r2, [r3, #0]
	delay_us(LCD_DELAY);

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
    48b6:	bf48      	it	mi
    48b8:	f040 0010 	orrmi.w	r0, r0, #16
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
    48bc:	0692      	lsls	r2, r2, #26
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
    48be:	681a      	ldr	r2, [r3, #0]

	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
    48c0:	bf48      	it	mi
    48c2:	f040 0008 	orrmi.w	r0, r0, #8
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
    48c6:	06d1      	lsls	r1, r2, #27
	if (LCD_PORTDATA_IN&LCD_PIN_D1)		value|=0x02;
    48c8:	681a      	ldr	r2, [r3, #0]
	if (LCD_PORTDATA_IN&LCD_PIN_D0)		value|=0x01;
    48ca:	681b      	ldr	r3, [r3, #0]
	if (LCD_PORTDATA_IN&LCD_PIN_D7)		value|=0x80;
	if (LCD_PORTDATA_IN&LCD_PIN_D6)		value|=0x40;
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
    48cc:	bf48      	it	mi
    48ce:	f040 0004 	orrmi.w	r0, r0, #4
	if (LCD_PORTDATA_IN&LCD_PIN_D1)		value|=0x02;
    48d2:	0712      	lsls	r2, r2, #28
    48d4:	bf48      	it	mi
    48d6:	f040 0002 	orrmi.w	r0, r0, #2
	if (LCD_PORTDATA_IN&LCD_PIN_D0)		value|=0x01;
    48da:	075b      	lsls	r3, r3, #29

	LCD_PORTCTRL_CLR = LCD_PIN_E;			// E = 0
    48dc:	f04f 7380 	mov.w	r3, #16777216	; 0x1000000
	if (LCD_PORTDATA_IN&LCD_PIN_D5)		value|=0x20;
	if (LCD_PORTDATA_IN&LCD_PIN_D4)		value|=0x10;
	if (LCD_PORTDATA_IN&LCD_PIN_D3)		value|=0x08;
	if (LCD_PORTDATA_IN&LCD_PIN_D2)		value|=0x04;
	if (LCD_PORTDATA_IN&LCD_PIN_D1)		value|=0x02;
	if (LCD_PORTDATA_IN&LCD_PIN_D0)		value|=0x01;
    48e0:	bf48      	it	mi
    48e2:	f040 0001 	orrmi.w	r0, r0, #1

	LCD_PORTCTRL_CLR = LCD_PIN_E;			// E = 0
    48e6:	6023      	str	r3, [r4, #0]

	return value;
}
    48e8:	bd10      	pop	{r4, pc}
    48ea:	bf00      	nop
    48ec:	2009c038 	.word	0x2009c038
    48f0:	2009c03c 	.word	0x2009c03c
    48f4:	2009c054 	.word	0x2009c054

Disassembly of section .text.lcd_write:

000048f8 <lcd_write>:
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza escrever um comando
//			1:Sinaliza escrever um dado
void lcd_write(u8 value, u8 rs) {
	LCD_PORTDATA_DIR |= (LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como saida
    48f8:	4b2d      	ldr	r3, [pc, #180]	; (49b0 <lcd_write+0xb8>)
//		wr: 0: Sinaliza escrita
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza escrever um comando
//			1:Sinaliza escrever um dado
void lcd_write(u8 value, u8 rs) {
    48fa:	b570      	push	{r4, r5, r6, lr}
	LCD_PORTDATA_DIR |= (LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como saida
    48fc:	681a      	ldr	r2, [r3, #0]
	LCD_PORTCTRL_CLR = LCD_PIN_WR;			// WR = 0;
    48fe:	4c2d      	ldr	r4, [pc, #180]	; (49b4 <lcd_write+0xbc>)
//		e:	0: Disabilita acesso ao display
//			1: Habilita acesso ao display
// 		rs: 0: Sinaliza escrever um comando
//			1:Sinaliza escrever um dado
void lcd_write(u8 value, u8 rs) {
	LCD_PORTDATA_DIR |= (LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como saida
    4900:	f442 727f 	orr.w	r2, r2, #1020	; 0x3fc
    4904:	601a      	str	r2, [r3, #0]
	LCD_PORTCTRL_CLR = LCD_PIN_WR;			// WR = 0;
    4906:	f44f 0200 	mov.w	r2, #8388608	; 0x800000
    490a:	6022      	str	r2, [r4, #0]
    490c:	461d      	mov	r5, r3
    490e:	f44f 0280 	mov.w	r2, #4194304	; 0x400000
    4912:	3b08      	subs	r3, #8

	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
    4914:	b109      	cbz	r1, 491a <lcd_write+0x22>
    4916:	601a      	str	r2, [r3, #0]
    4918:	e000      	b.n	491c <lcd_write+0x24>
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;
    491a:	6022      	str	r2, [r4, #0]

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
    491c:	f010 0f80 	tst.w	r0, #128	; 0x80
    4920:	bf14      	ite	ne
    4922:	4925      	ldrne	r1, [pc, #148]	; (49b8 <lcd_write+0xc0>)
    4924:	4925      	ldreq	r1, [pc, #148]	; (49bc <lcd_write+0xc4>)
    4926:	f44f 7200 	mov.w	r2, #512	; 0x200
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
    492a:	f010 0f40 	tst.w	r0, #64	; 0x40

	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
    492e:	600a      	str	r2, [r1, #0]
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
    4930:	bf14      	ite	ne
    4932:	4921      	ldrne	r1, [pc, #132]	; (49b8 <lcd_write+0xc0>)
    4934:	4921      	ldreq	r1, [pc, #132]	; (49bc <lcd_write+0xc4>)
    4936:	f44f 7280 	mov.w	r2, #256	; 0x100
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
    493a:	f010 0f20 	tst.w	r0, #32
	if (rs)	LCD_PORTCTRL_SET = LCD_PIN_RS;	// RS = 1;
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
    493e:	600a      	str	r2, [r1, #0]
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
    4940:	bf14      	ite	ne
    4942:	491d      	ldrne	r1, [pc, #116]	; (49b8 <lcd_write+0xc0>)
    4944:	491d      	ldreq	r1, [pc, #116]	; (49bc <lcd_write+0xc4>)
    4946:	2280      	movs	r2, #128	; 0x80
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
    4948:	f010 0f10 	tst.w	r0, #16
	else	LCD_PORTCTRL_CLR = LCD_PIN_RS;	// RS = 0;

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
    494c:	600a      	str	r2, [r1, #0]
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
    494e:	bf14      	ite	ne
    4950:	4919      	ldrne	r1, [pc, #100]	; (49b8 <lcd_write+0xc0>)
    4952:	491a      	ldreq	r1, [pc, #104]	; (49bc <lcd_write+0xc4>)
    4954:	2240      	movs	r2, #64	; 0x40
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
    4956:	f010 0f08 	tst.w	r0, #8

	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
    495a:	600a      	str	r2, [r1, #0]
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
    495c:	bf14      	ite	ne
    495e:	4916      	ldrne	r1, [pc, #88]	; (49b8 <lcd_write+0xc0>)
    4960:	4916      	ldreq	r1, [pc, #88]	; (49bc <lcd_write+0xc4>)
    4962:	2220      	movs	r2, #32
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
    4964:	f010 0f04 	tst.w	r0, #4
	// Atualizar barramento do LCD com o valor do registrador
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
    4968:	600a      	str	r2, [r1, #0]
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
    496a:	bf14      	ite	ne
    496c:	4912      	ldrne	r1, [pc, #72]	; (49b8 <lcd_write+0xc0>)
    496e:	4913      	ldreq	r1, [pc, #76]	; (49bc <lcd_write+0xc4>)
    4970:	2210      	movs	r2, #16
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
    4972:	f010 0f02 	tst.w	r0, #2
	if (value&0x80) LCD_PORTDATA_SET = LCD_PIN_D7; else LCD_PORTDATA_CLR = LCD_PIN_D7;
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
    4976:	600a      	str	r2, [r1, #0]
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
    4978:	bf14      	ite	ne
    497a:	490f      	ldrne	r1, [pc, #60]	; (49b8 <lcd_write+0xc0>)
    497c:	490f      	ldreq	r1, [pc, #60]	; (49bc <lcd_write+0xc4>)
    497e:	2208      	movs	r2, #8
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;
    4980:	f010 0f01 	tst.w	r0, #1
	if (value&0x40) LCD_PORTDATA_SET = LCD_PIN_D6; else LCD_PORTDATA_CLR = LCD_PIN_D6;
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
    4984:	600a      	str	r2, [r1, #0]
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;
    4986:	bf14      	ite	ne
    4988:	490b      	ldrne	r1, [pc, #44]	; (49b8 <lcd_write+0xc0>)
    498a:	490c      	ldreq	r1, [pc, #48]	; (49bc <lcd_write+0xc4>)
    498c:	2204      	movs	r2, #4

	LCD_PORTCTRL_SET = LCD_PIN_E;	// E = 1
    498e:	f04f 7680 	mov.w	r6, #16777216	; 0x1000000
	if (value&0x20) LCD_PORTDATA_SET = LCD_PIN_D5; else LCD_PORTDATA_CLR = LCD_PIN_D5;
	if (value&0x10) LCD_PORTDATA_SET = LCD_PIN_D4; else LCD_PORTDATA_CLR = LCD_PIN_D4;
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;
    4992:	600a      	str	r2, [r1, #0]

	LCD_PORTCTRL_SET = LCD_PIN_E;	// E = 1
	delay_us(LCD_DELAY);
    4994:	2021      	movs	r0, #33	; 0x21
	if (value&0x08) LCD_PORTDATA_SET = LCD_PIN_D3; else LCD_PORTDATA_CLR = LCD_PIN_D3;
	if (value&0x04) LCD_PORTDATA_SET = LCD_PIN_D2; else LCD_PORTDATA_CLR = LCD_PIN_D2;
	if (value&0x02) LCD_PORTDATA_SET = LCD_PIN_D1; else LCD_PORTDATA_CLR = LCD_PIN_D1;
	if (value&0x01) LCD_PORTDATA_SET = LCD_PIN_D0; else LCD_PORTDATA_CLR = LCD_PIN_D0;

	LCD_PORTCTRL_SET = LCD_PIN_E;	// E = 1
    4996:	601e      	str	r6, [r3, #0]
	delay_us(LCD_DELAY);
    4998:	f7fd f8cc 	bl	1b34 <delay>
	LCD_PORTCTRL_CLR = LCD_PIN_E;	// E = 0
    499c:	6026      	str	r6, [r4, #0]
	delay_us(LCD_DELAY);
    499e:	2021      	movs	r0, #33	; 0x21
    49a0:	f7fd f8c8 	bl	1b34 <delay>
	LCD_PORTDATA_DIR &= ~(LCD_PIN_D7|LCD_PIN_D6|LCD_PIN_D5|LCD_PIN_D4|LCD_PIN_D3|LCD_PIN_D2|LCD_PIN_D1|LCD_PIN_D0); // Pinos dos dados como entrada
    49a4:	682b      	ldr	r3, [r5, #0]
    49a6:	f423 737f 	bic.w	r3, r3, #1020	; 0x3fc
    49aa:	602b      	str	r3, [r5, #0]
    49ac:	bd70      	pop	{r4, r5, r6, pc}
    49ae:	bf00      	nop
    49b0:	2009c040 	.word	0x2009c040
    49b4:	2009c03c 	.word	0x2009c03c
    49b8:	2009c058 	.word	0x2009c058
    49bc:	2009c05c 	.word	0x2009c05c

Disassembly of section .text.__get_current_locale:

000049c0 <__get_current_locale>:
    49c0:	4a03      	ldr	r2, [pc, #12]	; (49d0 <__get_current_locale+0x10>)
    49c2:	4b04      	ldr	r3, [pc, #16]	; (49d4 <__get_current_locale+0x14>)
    49c4:	6812      	ldr	r2, [r2, #0]
    49c6:	6b50      	ldr	r0, [r2, #52]	; 0x34
    49c8:	2800      	cmp	r0, #0
    49ca:	bf08      	it	eq
    49cc:	4618      	moveq	r0, r3
    49ce:	4770      	bx	lr
    49d0:	100005a8 	.word	0x100005a8
    49d4:	10000010 	.word	0x10000010

Disassembly of section .text.__locale_ctype_ptr:

000049d8 <__locale_ctype_ptr>:
    49d8:	b508      	push	{r3, lr}
    49da:	4b03      	ldr	r3, [pc, #12]	; (49e8 <__locale_ctype_ptr+0x10>)
    49dc:	6818      	ldr	r0, [r3, #0]
    49de:	f7ff ffef 	bl	49c0 <__get_current_locale>
    49e2:	f8d0 00ec 	ldr.w	r0, [r0, #236]	; 0xec
    49e6:	bd08      	pop	{r3, pc}
    49e8:	100005a8 	.word	0x100005a8

Disassembly of section .text.__ascii_mbtowc:

000049ec <__ascii_mbtowc>:
    49ec:	b082      	sub	sp, #8
    49ee:	b149      	cbz	r1, 4a04 <__ascii_mbtowc+0x18>
    49f0:	b15a      	cbz	r2, 4a0a <__ascii_mbtowc+0x1e>
    49f2:	b16b      	cbz	r3, 4a10 <__ascii_mbtowc+0x24>
    49f4:	7813      	ldrb	r3, [r2, #0]
    49f6:	600b      	str	r3, [r1, #0]
    49f8:	7812      	ldrb	r2, [r2, #0]
    49fa:	1c10      	adds	r0, r2, #0
    49fc:	bf18      	it	ne
    49fe:	2001      	movne	r0, #1
    4a00:	b002      	add	sp, #8
    4a02:	4770      	bx	lr
    4a04:	a901      	add	r1, sp, #4
    4a06:	2a00      	cmp	r2, #0
    4a08:	d1f3      	bne.n	49f2 <__ascii_mbtowc+0x6>
    4a0a:	4610      	mov	r0, r2
    4a0c:	b002      	add	sp, #8
    4a0e:	4770      	bx	lr
    4a10:	f06f 0001 	mvn.w	r0, #1
    4a14:	e7f4      	b.n	4a00 <__ascii_mbtowc+0x14>
    4a16:	bf00      	nop

Disassembly of section .text.memset:

00004a18 <memset>:
    4a18:	b470      	push	{r4, r5, r6}
    4a1a:	0784      	lsls	r4, r0, #30
    4a1c:	d046      	beq.n	4aac <memset+0x94>
    4a1e:	1e54      	subs	r4, r2, #1
    4a20:	2a00      	cmp	r2, #0
    4a22:	d041      	beq.n	4aa8 <memset+0x90>
    4a24:	b2cd      	uxtb	r5, r1
    4a26:	4603      	mov	r3, r0
    4a28:	e002      	b.n	4a30 <memset+0x18>
    4a2a:	1e62      	subs	r2, r4, #1
    4a2c:	b3e4      	cbz	r4, 4aa8 <memset+0x90>
    4a2e:	4614      	mov	r4, r2
    4a30:	f803 5b01 	strb.w	r5, [r3], #1
    4a34:	079a      	lsls	r2, r3, #30
    4a36:	d1f8      	bne.n	4a2a <memset+0x12>
    4a38:	2c03      	cmp	r4, #3
    4a3a:	d92e      	bls.n	4a9a <memset+0x82>
    4a3c:	b2cd      	uxtb	r5, r1
    4a3e:	ea45 2505 	orr.w	r5, r5, r5, lsl #8
    4a42:	2c0f      	cmp	r4, #15
    4a44:	ea45 4505 	orr.w	r5, r5, r5, lsl #16
    4a48:	d919      	bls.n	4a7e <memset+0x66>
    4a4a:	4626      	mov	r6, r4
    4a4c:	f103 0210 	add.w	r2, r3, #16
    4a50:	3e10      	subs	r6, #16
    4a52:	2e0f      	cmp	r6, #15
    4a54:	f842 5c10 	str.w	r5, [r2, #-16]
    4a58:	f842 5c0c 	str.w	r5, [r2, #-12]
    4a5c:	f842 5c08 	str.w	r5, [r2, #-8]
    4a60:	f842 5c04 	str.w	r5, [r2, #-4]
    4a64:	f102 0210 	add.w	r2, r2, #16
    4a68:	d8f2      	bhi.n	4a50 <memset+0x38>
    4a6a:	f1a4 0210 	sub.w	r2, r4, #16
    4a6e:	f022 020f 	bic.w	r2, r2, #15
    4a72:	f004 040f 	and.w	r4, r4, #15
    4a76:	3210      	adds	r2, #16
    4a78:	2c03      	cmp	r4, #3
    4a7a:	4413      	add	r3, r2
    4a7c:	d90d      	bls.n	4a9a <memset+0x82>
    4a7e:	461e      	mov	r6, r3
    4a80:	4622      	mov	r2, r4
    4a82:	3a04      	subs	r2, #4
    4a84:	2a03      	cmp	r2, #3
    4a86:	f846 5b04 	str.w	r5, [r6], #4
    4a8a:	d8fa      	bhi.n	4a82 <memset+0x6a>
    4a8c:	1f22      	subs	r2, r4, #4
    4a8e:	f022 0203 	bic.w	r2, r2, #3
    4a92:	3204      	adds	r2, #4
    4a94:	4413      	add	r3, r2
    4a96:	f004 0403 	and.w	r4, r4, #3
    4a9a:	b12c      	cbz	r4, 4aa8 <memset+0x90>
    4a9c:	b2c9      	uxtb	r1, r1
    4a9e:	441c      	add	r4, r3
    4aa0:	f803 1b01 	strb.w	r1, [r3], #1
    4aa4:	42a3      	cmp	r3, r4
    4aa6:	d1fb      	bne.n	4aa0 <memset+0x88>
    4aa8:	bc70      	pop	{r4, r5, r6}
    4aaa:	4770      	bx	lr
    4aac:	4614      	mov	r4, r2
    4aae:	4603      	mov	r3, r0
    4ab0:	e7c2      	b.n	4a38 <memset+0x20>
    4ab2:	bf00      	nop

Disassembly of section .text.strlen:

00004ab4 <strlen>:
    4ab4:	f020 0103 	bic.w	r1, r0, #3
    4ab8:	f010 0003 	ands.w	r0, r0, #3
    4abc:	f1c0 0000 	rsb	r0, r0, #0
    4ac0:	f851 3b04 	ldr.w	r3, [r1], #4
    4ac4:	f100 0c04 	add.w	ip, r0, #4
    4ac8:	ea4f 0ccc 	mov.w	ip, ip, lsl #3
    4acc:	f06f 0200 	mvn.w	r2, #0
    4ad0:	bf1c      	itt	ne
    4ad2:	fa22 f20c 	lsrne.w	r2, r2, ip
    4ad6:	4313      	orrne	r3, r2
    4ad8:	f04f 0c01 	mov.w	ip, #1
    4adc:	ea4c 2c0c 	orr.w	ip, ip, ip, lsl #8
    4ae0:	ea4c 4c0c 	orr.w	ip, ip, ip, lsl #16
    4ae4:	eba3 020c 	sub.w	r2, r3, ip
    4ae8:	ea22 0203 	bic.w	r2, r2, r3
    4aec:	ea12 12cc 	ands.w	r2, r2, ip, lsl #7
    4af0:	bf04      	itt	eq
    4af2:	f851 3b04 	ldreq.w	r3, [r1], #4
    4af6:	3004      	addeq	r0, #4
    4af8:	d0f4      	beq.n	4ae4 <strlen+0x30>
    4afa:	f1c2 0100 	rsb	r1, r2, #0
    4afe:	ea02 0201 	and.w	r2, r2, r1
    4b02:	fab2 f282 	clz	r2, r2
    4b06:	f1c2 021f 	rsb	r2, r2, #31
    4b0a:	eb00 00d2 	add.w	r0, r0, r2, lsr #3
    4b0e:	4770      	bx	lr

Disassembly of section .text.__ascii_wctomb:

00004b10 <__ascii_wctomb>:
    4b10:	b121      	cbz	r1, 4b1c <__ascii_wctomb+0xc>
    4b12:	2aff      	cmp	r2, #255	; 0xff
    4b14:	d804      	bhi.n	4b20 <__ascii_wctomb+0x10>
    4b16:	700a      	strb	r2, [r1, #0]
    4b18:	2001      	movs	r0, #1
    4b1a:	4770      	bx	lr
    4b1c:	4608      	mov	r0, r1
    4b1e:	4770      	bx	lr
    4b20:	238a      	movs	r3, #138	; 0x8a
    4b22:	6003      	str	r3, [r0, #0]
    4b24:	f04f 30ff 	mov.w	r0, #4294967295
    4b28:	4770      	bx	lr
    4b2a:	bf00      	nop
